diff options
Diffstat (limited to 'externals/dynarmic/tests')
37 files changed, 36539 insertions, 0 deletions
diff --git a/externals/dynarmic/tests/A32/fuzz_arm.cpp b/externals/dynarmic/tests/A32/fuzz_arm.cpp new file mode 100644 index 0000000000..cda424e27d --- /dev/null +++ b/externals/dynarmic/tests/A32/fuzz_arm.cpp @@ -0,0 +1,687 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2016 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <algorithm> +#include <array> +#include <cstdio> +#include <functional> +#include <tuple> +#include <type_traits> +#include <vector> + +#include <catch2/catch_test_macros.hpp> +#include <mcl/bit/bit_count.hpp> +#include <mcl/bit/swap.hpp> +#include <mcl/scope_exit.hpp> +#include <mcl/stdint.hpp> + +#include "../fuzz_util.h" +#include "../rand_int.h" +#include "../unicorn_emu/a32_unicorn.h" +#include "./testenv.h" +#include "dynarmic/common/fp/fpcr.h" +#include "dynarmic/common/fp/fpsr.h" +#include "dynarmic/common/llvm_disassemble.h" +#include "dynarmic/common/variant_util.h" +#include "dynarmic/frontend/A32/ITState.h" +#include "dynarmic/frontend/A32/a32_location_descriptor.h" +#include "dynarmic/frontend/A32/a32_types.h" +#include "dynarmic/frontend/A32/translate/a32_translate.h" +#include "dynarmic/interface/A32/a32.h" +#include "dynarmic/ir/basic_block.h" +#include "dynarmic/ir/location_descriptor.h" +#include "dynarmic/ir/opcodes.h" + +// Must be declared last for all necessary operator<< to be declared prior to this. +#include <fmt/format.h> +#include <fmt/ostream.h> + +namespace { +using namespace Dynarmic; + +template<typename Fn> +bool AnyLocationDescriptorForTerminalHas(IR::Terminal terminal, Fn fn) { + return Common::VisitVariant<bool>(terminal, [&](auto t) -> bool { + using T = std::decay_t<decltype(t)>; + if constexpr (std::is_same_v<T, IR::Term::Invalid>) { + return false; + } else if constexpr (std::is_same_v<T, IR::Term::ReturnToDispatch>) { + return false; + } else if constexpr (std::is_same_v<T, IR::Term::LinkBlock>) { + return fn(t.next); + } else if constexpr (std::is_same_v<T, IR::Term::LinkBlockFast>) { + return fn(t.next); + } else if constexpr (std::is_same_v<T, IR::Term::PopRSBHint>) { + return false; + } else if constexpr (std::is_same_v<T, IR::Term::Interpret>) { + return fn(t.next); + } else if constexpr (std::is_same_v<T, IR::Term::FastDispatchHint>) { + return false; + } else if constexpr (std::is_same_v<T, IR::Term::If>) { + return AnyLocationDescriptorForTerminalHas(t.then_, fn) || AnyLocationDescriptorForTerminalHas(t.else_, fn); + } else if constexpr (std::is_same_v<T, IR::Term::CheckBit>) { + return AnyLocationDescriptorForTerminalHas(t.then_, fn) || AnyLocationDescriptorForTerminalHas(t.else_, fn); + } else if constexpr (std::is_same_v<T, IR::Term::CheckHalt>) { + return AnyLocationDescriptorForTerminalHas(t.else_, fn); + } else { + ASSERT_MSG(false, "Invalid terminal type"); + return false; + } + }); +} + +bool ShouldTestInst(u32 instruction, u32 pc, bool is_thumb, bool is_last_inst, A32::ITState it_state = {}) { + const A32::LocationDescriptor location = A32::LocationDescriptor{pc, {}, {}}.SetTFlag(is_thumb).SetIT(it_state); + IR::Block block{location}; + const bool should_continue = A32::TranslateSingleInstruction(block, location, instruction); + + if (!should_continue && !is_last_inst) { + return false; + } + + if (auto terminal = block.GetTerminal(); boost::get<IR::Term::Interpret>(&terminal)) { + return false; + } + + if (AnyLocationDescriptorForTerminalHas(block.GetTerminal(), [&](IR::LocationDescriptor ld) { return A32::LocationDescriptor{ld}.PC() <= pc; })) { + return false; + } + + for (const auto& ir_inst : block) { + switch (ir_inst.GetOpcode()) { + case IR::Opcode::A32ExceptionRaised: + case IR::Opcode::A32CallSupervisor: + case IR::Opcode::A32CoprocInternalOperation: + case IR::Opcode::A32CoprocSendOneWord: + case IR::Opcode::A32CoprocSendTwoWords: + case IR::Opcode::A32CoprocGetOneWord: + case IR::Opcode::A32CoprocGetTwoWords: + case IR::Opcode::A32CoprocLoadWords: + case IR::Opcode::A32CoprocStoreWords: + return false; + // Currently unimplemented in Unicorn + case IR::Opcode::FPVectorRecipEstimate16: + case IR::Opcode::FPVectorRSqrtEstimate16: + case IR::Opcode::VectorPolynomialMultiplyLong64: + return false; + default: + continue; + } + } + + return true; +} + +u32 GenRandomArmInst(u32 pc, bool is_last_inst) { + static const struct InstructionGeneratorInfo { + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + } instructions = [] { + const std::vector<std::tuple<std::string, const char*>> list{ +#define INST(fn, name, bitstring) {#fn, bitstring}, +#include "dynarmic/frontend/A32/decoder/arm.inc" +#include "dynarmic/frontend/A32/decoder/asimd.inc" +#include "dynarmic/frontend/A32/decoder/vfp.inc" +#undef INST + }; + + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + + // List of instructions not to test + static constexpr std::array do_not_test{ + // Translating load/stores + "arm_LDRBT", "arm_LDRBT", "arm_LDRHT", "arm_LDRHT", "arm_LDRSBT", "arm_LDRSBT", "arm_LDRSHT", "arm_LDRSHT", "arm_LDRT", "arm_LDRT", + "arm_STRBT", "arm_STRBT", "arm_STRHT", "arm_STRHT", "arm_STRT", "arm_STRT", + // Exclusive load/stores + "arm_LDREXB", "arm_LDREXD", "arm_LDREXH", "arm_LDREX", "arm_LDAEXB", "arm_LDAEXD", "arm_LDAEXH", "arm_LDAEX", + "arm_STREXB", "arm_STREXD", "arm_STREXH", "arm_STREX", "arm_STLEXB", "arm_STLEXD", "arm_STLEXH", "arm_STLEX", + "arm_SWP", "arm_SWPB", + // Elevated load/store multiple instructions. + "arm_LDM_eret", "arm_LDM_usr", + "arm_STM_usr", + // Hint instructions + "arm_NOP", "arm_PLD_imm", "arm_PLD_reg", "arm_SEV", + "arm_WFE", "arm_WFI", "arm_YIELD", + // E, T, J + "arm_BLX_reg", "arm_BLX_imm", "arm_BXJ", "arm_SETEND", + // Coprocessor + "arm_CDP", "arm_LDC", "arm_MCR", "arm_MCRR", "arm_MRC", "arm_MRRC", "arm_STC", + // System + "arm_CPS", "arm_RFE", "arm_SRS", + // Undefined + "arm_UDF", + // FPSCR is inaccurate + "vfp_VMRS", + // Incorrect Unicorn implementations + "asimd_VRECPS", // Unicorn does not fuse the multiply and subtraction, resulting in being off by 1ULP. + "asimd_VRSQRTS", // Unicorn does not fuse the multiply and subtraction, resulting in being off by 1ULP. + "vfp_VCVT_from_fixed", // Unicorn does not do round-to-nearest-even for this instruction correctly. + }; + + for (const auto& [fn, bitstring] : list) { + if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + invalid.emplace_back(InstructionGenerator{bitstring}); + continue; + } + generators.emplace_back(InstructionGenerator{bitstring}); + } + return InstructionGeneratorInfo{generators, invalid}; + }(); + + while (true) { + const size_t index = RandInt<size_t>(0, instructions.generators.size() - 1); + const u32 inst = instructions.generators[index].Generate(); + + if ((instructions.generators[index].Mask() & 0xF0000000) == 0 && (inst & 0xF0000000) == 0xF0000000) { + continue; + } + + if (ShouldTestInst(inst, pc, false, is_last_inst)) { + return inst; + } + } +} + +std::vector<u16> GenRandomThumbInst(u32 pc, bool is_last_inst, A32::ITState it_state = {}) { + static const struct InstructionGeneratorInfo { + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + } instructions = [] { + const std::vector<std::tuple<std::string, const char*>> list{ +#define INST(fn, name, bitstring) {#fn, bitstring}, +#include "dynarmic/frontend/A32/decoder/thumb16.inc" +#include "dynarmic/frontend/A32/decoder/thumb32.inc" +#undef INST + }; + + const std::vector<std::tuple<std::string, const char*>> vfp_list{ +#define INST(fn, name, bitstring) {#fn, bitstring}, +#include "dynarmic/frontend/A32/decoder/vfp.inc" +#undef INST + }; + + const std::vector<std::tuple<std::string, const char*>> asimd_list{ +#define INST(fn, name, bitstring) {#fn, bitstring}, +#include "dynarmic/frontend/A32/decoder/asimd.inc" +#undef INST + }; + + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + + // List of instructions not to test + static constexpr std::array do_not_test{ + "thumb16_BKPT", + "thumb16_IT", + "thumb16_SETEND", + + // Exclusive load/stores + "thumb32_LDREX", + "thumb32_LDREXB", + "thumb32_LDREXD", + "thumb32_LDREXH", + "thumb32_STREX", + "thumb32_STREXB", + "thumb32_STREXD", + "thumb32_STREXH", + + // FPSCR is inaccurate + "vfp_VMRS", + + // Unicorn is incorrect? + "thumb32_MRS_reg", + "thumb32_MSR_reg", + + // Unicorn has incorrect implementation (incorrect rounding and unsets CPSR.T??) + "vfp_VCVT_to_fixed", + "vfp_VCVT_from_fixed", + "asimd_VRECPS", // Unicorn does not fuse the multiply and subtraction, resulting in being off by 1ULP. + "asimd_VRSQRTS", // Unicorn does not fuse the multiply and subtraction, resulting in being off by 1ULP. + + // Coprocessor + "thumb32_CDP", + "thumb32_LDC", + "thumb32_MCR", + "thumb32_MCRR", + "thumb32_MRC", + "thumb32_MRRC", + "thumb32_STC", + }; + + for (const auto& [fn, bitstring] : list) { + if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + invalid.emplace_back(InstructionGenerator{bitstring}); + continue; + } + generators.emplace_back(InstructionGenerator{bitstring}); + } + for (const auto& [fn, bs] : vfp_list) { + std::string bitstring = bs; + if (bitstring.substr(0, 4) == "cccc" || bitstring.substr(0, 4) == "----") { + bitstring.replace(0, 4, "1110"); + } + if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + invalid.emplace_back(InstructionGenerator{bitstring.c_str()}); + continue; + } + generators.emplace_back(InstructionGenerator{bitstring.c_str()}); + } + for (const auto& [fn, bs] : asimd_list) { + std::string bitstring = bs; + if (bitstring.substr(0, 7) == "1111001") { + const char U = bitstring[7]; + bitstring.replace(0, 8, "111-1111"); + bitstring[3] = U; + } else if (bitstring.substr(0, 8) == "11110100") { + bitstring.replace(0, 8, "11111001"); + } else { + ASSERT_FALSE("Unhandled ASIMD instruction: {} {}", fn, bs); + } + if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + invalid.emplace_back(InstructionGenerator{bitstring.c_str()}); + continue; + } + generators.emplace_back(InstructionGenerator{bitstring.c_str()}); + } + return InstructionGeneratorInfo{generators, invalid}; + }(); + + while (true) { + const size_t index = RandInt<size_t>(0, instructions.generators.size() - 1); + const u32 inst = instructions.generators[index].Generate(); + const bool is_four_bytes = (inst >> 16) != 0; + + if (ShouldTestInst(is_four_bytes ? mcl::bit::swap_halves_32(inst) : inst, pc, true, is_last_inst, it_state)) { + if (is_four_bytes) + return {static_cast<u16>(inst >> 16), static_cast<u16>(inst)}; + return {static_cast<u16>(inst)}; + } + } +} + +template<typename TestEnv> +Dynarmic::A32::UserConfig GetUserConfig(TestEnv& testenv) { + Dynarmic::A32::UserConfig user_config; + user_config.optimizations &= ~OptimizationFlag::FastDispatch; + user_config.callbacks = &testenv; + user_config.always_little_endian = true; + return user_config; +} + +template<typename TestEnv> +static void RunTestInstance(Dynarmic::A32::Jit& jit, + A32Unicorn<TestEnv>& uni, + TestEnv& jit_env, + TestEnv& uni_env, + const typename A32Unicorn<TestEnv>::RegisterArray& regs, + const typename A32Unicorn<TestEnv>::ExtRegArray& vecs, + const std::vector<typename TestEnv::InstructionType>& instructions, + const u32 cpsr, + const u32 fpscr, + const size_t ticks_left) { + const u32 initial_pc = regs[15]; + const u32 num_words = initial_pc / sizeof(typename TestEnv::InstructionType); + const u32 code_mem_size = num_words + static_cast<u32>(instructions.size()); + const u32 expected_end_pc = code_mem_size * sizeof(typename TestEnv::InstructionType); + + jit_env.code_mem.resize(code_mem_size); + uni_env.code_mem.resize(code_mem_size); + std::fill(jit_env.code_mem.begin(), jit_env.code_mem.end(), TestEnv::infinite_loop); + std::fill(uni_env.code_mem.begin(), uni_env.code_mem.end(), TestEnv::infinite_loop); + + std::copy(instructions.begin(), instructions.end(), jit_env.code_mem.begin() + num_words); + std::copy(instructions.begin(), instructions.end(), uni_env.code_mem.begin() + num_words); + jit_env.PadCodeMem(); + uni_env.PadCodeMem(); + jit_env.modified_memory.clear(); + uni_env.modified_memory.clear(); + jit_env.interrupts.clear(); + uni_env.interrupts.clear(); + + jit.Regs() = regs; + jit.ExtRegs() = vecs; + jit.SetFpscr(fpscr); + jit.SetCpsr(cpsr); + jit.ClearCache(); + uni.SetRegisters(regs); + uni.SetExtRegs(vecs); + uni.SetFpscr(fpscr); + uni.EnableFloatingPointAccess(); + uni.SetCpsr(cpsr); + uni.ClearPageCache(); + + jit_env.ticks_left = ticks_left; + jit.Run(); + + uni_env.ticks_left = instructions.size(); // Unicorn counts thumb instructions weirdly. + uni.Run(); + + SCOPE_FAIL { + fmt::print("Instruction Listing:\n"); + fmt::print("{}\n", Common::DisassembleAArch32(std::is_same_v<TestEnv, ThumbTestEnv>, initial_pc, (const u8*)instructions.data(), instructions.size() * sizeof(instructions[0]))); + + fmt::print("Initial register listing:\n"); + for (size_t i = 0; i < regs.size(); ++i) { + fmt::print("{:3s}: {:08x}\n", static_cast<A32::Reg>(i), regs[i]); + } + for (size_t i = 0; i < vecs.size(); ++i) { + fmt::print("{:3s}: {:08x}\n", static_cast<A32::ExtReg>(i), vecs[i]); + } + fmt::print("cpsr {:08x}\n", cpsr); + fmt::print("fpcr {:08x}\n", fpscr); + fmt::print("fpcr.AHP {}\n", FP::FPCR{fpscr}.AHP()); + fmt::print("fpcr.DN {}\n", FP::FPCR{fpscr}.DN()); + fmt::print("fpcr.FZ {}\n", FP::FPCR{fpscr}.FZ()); + fmt::print("fpcr.RMode {}\n", static_cast<size_t>(FP::FPCR{fpscr}.RMode())); + fmt::print("fpcr.FZ16 {}\n", FP::FPCR{fpscr}.FZ16()); + fmt::print("\n"); + + fmt::print("Final register listing:\n"); + fmt::print(" unicorn dynarmic\n"); + const auto uni_regs = uni.GetRegisters(); + for (size_t i = 0; i < regs.size(); ++i) { + fmt::print("{:3s}: {:08x} {:08x} {}\n", static_cast<A32::Reg>(i), uni_regs[i], jit.Regs()[i], uni_regs[i] != jit.Regs()[i] ? "*" : ""); + } + const auto uni_ext_regs = uni.GetExtRegs(); + for (size_t i = 0; i < vecs.size(); ++i) { + fmt::print("s{:2d}: {:08x} {:08x} {}\n", static_cast<size_t>(i), uni_ext_regs[i], jit.ExtRegs()[i], uni_ext_regs[i] != jit.ExtRegs()[i] ? "*" : ""); + } + fmt::print("cpsr {:08x} {:08x} {}\n", uni.GetCpsr(), jit.Cpsr(), uni.GetCpsr() != jit.Cpsr() ? "*" : ""); + fmt::print("fpsr {:08x} {:08x} {}\n", uni.GetFpscr(), jit.Fpscr(), (uni.GetFpscr() & 0xF0000000) != (jit.Fpscr() & 0xF0000000) ? "*" : ""); + fmt::print("\n"); + + fmt::print("Modified memory:\n"); + fmt::print(" uni dyn\n"); + auto uni_iter = uni_env.modified_memory.begin(); + auto jit_iter = jit_env.modified_memory.begin(); + while (uni_iter != uni_env.modified_memory.end() || jit_iter != jit_env.modified_memory.end()) { + if (uni_iter == uni_env.modified_memory.end() || (jit_iter != jit_env.modified_memory.end() && uni_iter->first > jit_iter->first)) { + fmt::print("{:08x}: {:02x} *\n", jit_iter->first, jit_iter->second); + jit_iter++; + } else if (jit_iter == jit_env.modified_memory.end() || jit_iter->first > uni_iter->first) { + fmt::print("{:08x}: {:02x} *\n", uni_iter->first, uni_iter->second); + uni_iter++; + } else if (uni_iter->first == jit_iter->first) { + fmt::print("{:08x}: {:02x} {:02x} {}\n", uni_iter->first, uni_iter->second, jit_iter->second, uni_iter->second != jit_iter->second ? "*" : ""); + uni_iter++; + jit_iter++; + } + } + fmt::print("\n"); + + fmt::print("x86_64:\n"); + jit.DumpDisassembly(); + + fmt::print("Interrupts:\n"); + for (const auto& i : uni_env.interrupts) { + std::puts(i.c_str()); + } + }; + + REQUIRE(uni_env.code_mem_modified_by_guest == jit_env.code_mem_modified_by_guest); + if (uni_env.code_mem_modified_by_guest) { + return; + } + + // Qemu doesn't do Thumb transitions?? + { + const u32 uni_pc = uni.GetPC(); + const bool is_thumb = (jit.Cpsr() & (1 << 5)) != 0; + const u32 new_uni_pc = uni_pc & (is_thumb ? 0xFFFFFFFE : 0xFFFFFFFC); + uni.SetPC(new_uni_pc); + } + + if (uni.GetRegisters()[15] > jit.Regs()[15]) { + int trials = 0; + while (jit.Regs()[15] >= initial_pc && jit.Regs()[15] < expected_end_pc && trials++ < 100 && uni.GetRegisters()[15] != jit.Regs()[15]) { + fmt::print("Warning: Possible unicorn overrrun, attempt recovery\n"); + jit.Step(); + } + } + + REQUIRE(uni.GetRegisters() == jit.Regs()); + REQUIRE(uni.GetExtRegs() == jit.ExtRegs()); + REQUIRE((uni.GetCpsr() & 0xFFFFFDDF) == (jit.Cpsr() & 0xFFFFFDDF)); + REQUIRE((uni.GetFpscr() & 0xF8000000) == (jit.Fpscr() & 0xF8000000)); + REQUIRE(uni_env.modified_memory == jit_env.modified_memory); + REQUIRE(uni_env.interrupts.empty()); +} +} // Anonymous namespace + +TEST_CASE("A32: Single random arm instruction", "[arm]") { + ArmTestEnv jit_env{}; + ArmTestEnv uni_env{}; + + Dynarmic::A32::Jit jit{GetUserConfig(jit_env)}; + A32Unicorn<ArmTestEnv> uni{uni_env}; + + A32Unicorn<ArmTestEnv>::RegisterArray regs; + A32Unicorn<ArmTestEnv>::ExtRegArray ext_reg; + std::vector<u32> instructions(1); + + for (size_t iteration = 0; iteration < 100000; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + std::generate(ext_reg.begin(), ext_reg.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + + const u32 start_address = 100; + const u32 cpsr = (RandInt<u32>(0, 0xF) << 28) | 0x10; + const u32 fpcr = RandomFpcr(); + + instructions[0] = GenRandomArmInst(start_address, true); + + INFO("Instruction: 0x" << std::hex << instructions[0]); + + regs[15] = start_address; + RunTestInstance(jit, uni, jit_env, uni_env, regs, ext_reg, instructions, cpsr, fpcr, 1); + } +} + +TEST_CASE("A32: Small random arm block", "[arm]") { + ArmTestEnv jit_env{}; + ArmTestEnv uni_env{}; + + Dynarmic::A32::Jit jit{GetUserConfig(jit_env)}; + A32Unicorn<ArmTestEnv> uni{uni_env}; + + A32Unicorn<ArmTestEnv>::RegisterArray regs; + A32Unicorn<ArmTestEnv>::ExtRegArray ext_reg; + std::vector<u32> instructions(5); + + for (size_t iteration = 0; iteration < 100000; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + std::generate(ext_reg.begin(), ext_reg.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + + const u32 start_address = 100; + const u32 cpsr = (RandInt<u32>(0, 0xF) << 28) | 0x10; + const u32 fpcr = RandomFpcr(); + + instructions[0] = GenRandomArmInst(start_address + 0, false); + instructions[1] = GenRandomArmInst(start_address + 4, false); + instructions[2] = GenRandomArmInst(start_address + 8, false); + instructions[3] = GenRandomArmInst(start_address + 12, false); + instructions[4] = GenRandomArmInst(start_address + 16, true); + + INFO("Instruction 1: 0x" << std::hex << instructions[0]); + INFO("Instruction 2: 0x" << std::hex << instructions[1]); + INFO("Instruction 3: 0x" << std::hex << instructions[2]); + INFO("Instruction 4: 0x" << std::hex << instructions[3]); + INFO("Instruction 5: 0x" << std::hex << instructions[4]); + + regs[15] = start_address; + RunTestInstance(jit, uni, jit_env, uni_env, regs, ext_reg, instructions, cpsr, fpcr, 5); + } +} + +TEST_CASE("A32: Large random arm block", "[arm]") { + ArmTestEnv jit_env{}; + ArmTestEnv uni_env{}; + + Dynarmic::A32::Jit jit{GetUserConfig(jit_env)}; + A32Unicorn<ArmTestEnv> uni{uni_env}; + + A32Unicorn<ArmTestEnv>::RegisterArray regs; + A32Unicorn<ArmTestEnv>::ExtRegArray ext_reg; + + constexpr size_t instruction_count = 100; + std::vector<u32> instructions(instruction_count); + + for (size_t iteration = 0; iteration < 10000; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + std::generate(ext_reg.begin(), ext_reg.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + + const u64 start_address = 100; + const u32 cpsr = (RandInt<u32>(0, 0xF) << 28) | 0x10; + const u32 fpcr = RandomFpcr(); + + for (size_t j = 0; j < instruction_count; ++j) { + instructions[j] = GenRandomArmInst(start_address + j * 4, j == instruction_count - 1); + } + + regs[15] = start_address; + RunTestInstance(jit, uni, jit_env, uni_env, regs, ext_reg, instructions, cpsr, fpcr, 100); + } +} + +TEST_CASE("A32: Single random thumb instruction", "[thumb]") { + ThumbTestEnv jit_env{}; + ThumbTestEnv uni_env{}; + + Dynarmic::A32::Jit jit{GetUserConfig(jit_env)}; + A32Unicorn<ThumbTestEnv> uni{uni_env}; + + A32Unicorn<ThumbTestEnv>::RegisterArray regs; + A32Unicorn<ThumbTestEnv>::ExtRegArray ext_reg; + std::vector<u16> instructions; + + for (size_t iteration = 0; iteration < 100000; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + std::generate(ext_reg.begin(), ext_reg.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + + const u32 start_address = 100; + const u32 cpsr = (RandInt<u32>(0, 0xF) << 28) | 0x1F0; + const u32 fpcr = RandomFpcr(); + + instructions = GenRandomThumbInst(start_address, true); + + INFO("Instruction: 0x" << std::hex << instructions[0]); + + regs[15] = start_address; + RunTestInstance(jit, uni, jit_env, uni_env, regs, ext_reg, instructions, cpsr, fpcr, 1); + } +} + +TEST_CASE("A32: Single random thumb instruction (offset)", "[thumb]") { + ThumbTestEnv jit_env{}; + ThumbTestEnv uni_env{}; + + Dynarmic::A32::Jit jit{GetUserConfig(jit_env)}; + A32Unicorn<ThumbTestEnv> uni{uni_env}; + + A32Unicorn<ThumbTestEnv>::RegisterArray regs; + A32Unicorn<ThumbTestEnv>::ExtRegArray ext_reg; + std::vector<u16> instructions; + + for (size_t iteration = 0; iteration < 100000; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + std::generate(ext_reg.begin(), ext_reg.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + + const u32 start_address = 100; + const u32 cpsr = (RandInt<u32>(0, 0xF) << 28) | 0x1F0; + const u32 fpcr = RandomFpcr(); + + instructions.clear(); + instructions.push_back(0xbf00); // NOP + const std::vector<u16> inst = GenRandomThumbInst(start_address + 2, true); + instructions.insert(instructions.end(), inst.begin(), inst.end()); + + INFO("Instruction: 0x" << std::hex << inst[0]); + + regs[15] = start_address; + RunTestInstance(jit, uni, jit_env, uni_env, regs, ext_reg, instructions, cpsr, fpcr, 2); + } +} + +TEST_CASE("A32: Small random thumb block", "[thumb]") { + ThumbTestEnv jit_env{}; + ThumbTestEnv uni_env{}; + + Dynarmic::A32::Jit jit{GetUserConfig(jit_env)}; + A32Unicorn<ThumbTestEnv> uni{uni_env}; + + A32Unicorn<ThumbTestEnv>::RegisterArray regs; + A32Unicorn<ThumbTestEnv>::ExtRegArray ext_reg; + std::vector<u16> instructions; + + for (size_t iteration = 0; iteration < 100000; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + std::generate(ext_reg.begin(), ext_reg.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + + const u32 start_address = 100; + const u32 cpsr = (RandInt<u32>(0, 0xF) << 28) | 0x1F0; + const u32 fpcr = RandomFpcr(); + + instructions.clear(); + for (size_t i = 0; i < 5; i++) { + const std::vector<u16> inst = GenRandomThumbInst(start_address + instructions.size() * 2, i == 4); + instructions.insert(instructions.end(), inst.begin(), inst.end()); + } + + regs[15] = start_address; + RunTestInstance(jit, uni, jit_env, uni_env, regs, ext_reg, instructions, cpsr, fpcr, 5); + } +} + +TEST_CASE("A32: Test thumb IT instruction", "[thumb]") { + ThumbTestEnv jit_env{}; + ThumbTestEnv uni_env{}; + + Dynarmic::A32::Jit jit{GetUserConfig(jit_env)}; + A32Unicorn<ThumbTestEnv> uni{uni_env}; + + A32Unicorn<ThumbTestEnv>::RegisterArray regs; + A32Unicorn<ThumbTestEnv>::ExtRegArray ext_reg; + std::vector<u16> instructions; + + for (size_t iteration = 0; iteration < 100000; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + std::generate(ext_reg.begin(), ext_reg.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + + const size_t pre_instructions = RandInt<size_t>(0, 3); + const size_t post_instructions = RandInt<size_t>(5, 8); + + const u32 start_address = 100; + const u32 cpsr = (RandInt<u32>(0, 0xF) << 28) | 0x1F0; + const u32 fpcr = RandomFpcr(); + + instructions.clear(); + + for (size_t i = 0; i < pre_instructions; i++) { + const std::vector<u16> inst = GenRandomThumbInst(start_address + instructions.size() * 2, false); + instructions.insert(instructions.end(), inst.begin(), inst.end()); + } + + // Emit IT instruction + A32::ITState it_state = [&] { + while (true) { + const u16 imm8 = RandInt<u16>(0, 0xFF); + if (mcl::bit::get_bits<0, 3>(imm8) == 0b0000 || mcl::bit::get_bits<4, 7>(imm8) == 0b1111 || (mcl::bit::get_bits<4, 7>(imm8) == 0b1110 && mcl::bit::count_ones(mcl::bit::get_bits<0, 3>(imm8)) != 1)) { + continue; + } + instructions.push_back(0b1011111100000000 | imm8); + return A32::ITState{static_cast<u8>(imm8)}; + } + }(); + + for (size_t i = 0; i < post_instructions; i++) { + const std::vector<u16> inst = GenRandomThumbInst(start_address + instructions.size() * 2, i == post_instructions - 1, it_state); + instructions.insert(instructions.end(), inst.begin(), inst.end()); + it_state = it_state.Advance(); + } + + regs[15] = start_address; + RunTestInstance(jit, uni, jit_env, uni_env, regs, ext_reg, instructions, cpsr, fpcr, pre_instructions + 1 + post_instructions); + } +} diff --git a/externals/dynarmic/tests/A32/fuzz_thumb.cpp b/externals/dynarmic/tests/A32/fuzz_thumb.cpp new file mode 100644 index 0000000000..f13c5ee018 --- /dev/null +++ b/externals/dynarmic/tests/A32/fuzz_thumb.cpp @@ -0,0 +1,541 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2016 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <algorithm> +#include <array> +#include <cinttypes> +#include <cstdio> +#include <cstring> +#include <functional> +#include <string_view> +#include <tuple> + +#include <catch2/catch_test_macros.hpp> +#include <mcl/bit/bit_field.hpp> +#include <mcl/stdint.hpp> + +#include "../rand_int.h" +#include "../unicorn_emu/a32_unicorn.h" +#include "./testenv.h" +#include "dynarmic/frontend/A32/FPSCR.h" +#include "dynarmic/frontend/A32/PSR.h" +#include "dynarmic/frontend/A32/a32_location_descriptor.h" +#include "dynarmic/frontend/A32/disassembler/disassembler.h" +#include "dynarmic/frontend/A32/translate/a32_translate.h" +#include "dynarmic/interface/A32/a32.h" +#include "dynarmic/ir/basic_block.h" +#include "dynarmic/ir/opt/passes.h" + +using namespace Dynarmic; + +static A32::UserConfig GetUserConfig(ThumbTestEnv* testenv) { + A32::UserConfig user_config; + user_config.optimizations &= ~OptimizationFlag::FastDispatch; + user_config.callbacks = testenv; + return user_config; +} + +using WriteRecords = std::map<u32, u8>; + +struct ThumbInstGen final { +public: + ThumbInstGen( + std::string_view format, std::function<bool(u32)> is_valid = [](u32) { return true; }) + : is_valid(is_valid) { + REQUIRE((format.size() == 16 || format.size() == 32)); + + const auto bit_size = format.size(); + + for (size_t i = 0; i < bit_size; i++) { + const u32 bit = 1U << (bit_size - 1 - i); + switch (format[i]) { + case '0': + mask |= bit; + break; + case '1': + bits |= bit; + mask |= bit; + break; + default: + // Do nothing + break; + } + } + } + + u16 Generate16() const { + u32 inst; + + do { + const auto random = RandInt<u16>(0, 0xFFFF); + inst = bits | (random & ~mask); + } while (!is_valid(inst)); + + ASSERT((inst & mask) == bits); + + return static_cast<u16>(inst); + } + + u32 Generate32() const { + u32 inst; + + do { + const auto random = RandInt<u32>(0, 0xFFFFFFFF); + inst = bits | (random & ~mask); + } while (!is_valid(inst)); + + ASSERT((inst & mask) == bits); + + return inst; + } + +private: + u32 bits = 0; + u32 mask = 0; + std::function<bool(u32)> is_valid; +}; + +static bool DoesBehaviorMatch(const A32Unicorn<ThumbTestEnv>& uni, const A32::Jit& jit, const WriteRecords& interp_write_records, const WriteRecords& jit_write_records) { + const auto interp_regs = uni.GetRegisters(); + const auto jit_regs = jit.Regs(); + + return std::equal(interp_regs.begin(), interp_regs.end(), jit_regs.begin(), jit_regs.end()) && uni.GetCpsr() == jit.Cpsr() && interp_write_records == jit_write_records; +} + +static void RunInstance(size_t run_number, ThumbTestEnv& test_env, A32Unicorn<ThumbTestEnv>& uni, A32::Jit& jit, const ThumbTestEnv::RegisterArray& initial_regs, size_t instruction_count, size_t instructions_to_execute_count) { + uni.ClearPageCache(); + jit.ClearCache(); + + // Setup initial state + + uni.SetCpsr(0x000001F0); + uni.SetRegisters(initial_regs); + jit.SetCpsr(0x000001F0); + jit.Regs() = initial_regs; + + // Run interpreter + test_env.modified_memory.clear(); + test_env.ticks_left = instructions_to_execute_count; + uni.SetPC(uni.GetPC() | 1); + uni.Run(); + const bool uni_code_memory_modified = test_env.code_mem_modified_by_guest; + const auto interp_write_records = test_env.modified_memory; + + // Run jit + test_env.code_mem_modified_by_guest = false; + test_env.modified_memory.clear(); + test_env.ticks_left = instructions_to_execute_count; + jit.Run(); + const bool jit_code_memory_modified = test_env.code_mem_modified_by_guest; + const auto jit_write_records = test_env.modified_memory; + test_env.code_mem_modified_by_guest = false; + + REQUIRE(uni_code_memory_modified == jit_code_memory_modified); + if (uni_code_memory_modified) { + return; + } + + // Compare + if (!DoesBehaviorMatch(uni, jit, interp_write_records, jit_write_records)) { + printf("Failed at execution number %zu\n", run_number); + + printf("\nInstruction Listing: \n"); + for (size_t i = 0; i < instruction_count; i++) { + printf("%04x %s\n", test_env.code_mem[i], A32::DisassembleThumb16(test_env.code_mem[i]).c_str()); + } + + printf("\nInitial Register Listing: \n"); + for (size_t i = 0; i < initial_regs.size(); i++) { + printf("%4zu: %08x\n", i, initial_regs[i]); + } + + printf("\nFinal Register Listing: \n"); + printf(" unicorn jit\n"); + const auto uni_registers = uni.GetRegisters(); + for (size_t i = 0; i < uni_registers.size(); i++) { + printf("%4zu: %08x %08x %s\n", i, uni_registers[i], jit.Regs()[i], uni_registers[i] != jit.Regs()[i] ? "*" : ""); + } + printf("CPSR: %08x %08x %s\n", uni.GetCpsr(), jit.Cpsr(), uni.GetCpsr() != jit.Cpsr() ? "*" : ""); + + printf("\nUnicorn Write Records:\n"); + for (const auto& record : interp_write_records) { + printf("[%08x] = %02x\n", record.first, record.second); + } + + printf("\nJIT Write Records:\n"); + for (const auto& record : jit_write_records) { + printf("[%08x] = %02x\n", record.first, record.second); + } + + A32::PSR cpsr; + cpsr.T(true); + + size_t num_insts = 0; + while (num_insts < instructions_to_execute_count) { + A32::LocationDescriptor descriptor = {u32(num_insts * 4), cpsr, A32::FPSCR{}}; + IR::Block ir_block = A32::Translate(descriptor, &test_env, {}); + Optimization::NamingPass(ir_block); + Optimization::A32GetSetElimination(ir_block, {.convert_nz_to_nzc = true}); + Optimization::DeadCodeElimination(ir_block); + Optimization::A32ConstantMemoryReads(ir_block, &test_env); + Optimization::ConstantPropagation(ir_block); + Optimization::DeadCodeElimination(ir_block); + Optimization::VerificationPass(ir_block); + printf("\n\nIR:\n%s", IR::DumpBlock(ir_block).c_str()); + printf("\n\nx86_64:\n"); + jit.DumpDisassembly(); + num_insts += ir_block.CycleCount(); + } + +#ifdef _MSC_VER + __debugbreak(); +#endif + FAIL(); + } +} + +void FuzzJitThumb16(const size_t instruction_count, const size_t instructions_to_execute_count, const size_t run_count, const std::function<u16()> instruction_generator) { + ThumbTestEnv test_env; + + // Prepare memory. + test_env.code_mem.resize(instruction_count + 1); + test_env.code_mem.back() = 0xE7FE; // b +#0 + + // Prepare test subjects + A32Unicorn uni{test_env}; + A32::Jit jit{GetUserConfig(&test_env)}; + + for (size_t run_number = 0; run_number < run_count; run_number++) { + ThumbTestEnv::RegisterArray initial_regs; + std::generate_n(initial_regs.begin(), initial_regs.size() - 1, [] { return RandInt<u32>(0, 0xFFFFFFFF); }); + initial_regs[15] = 0; + + std::generate_n(test_env.code_mem.begin(), instruction_count, instruction_generator); + + RunInstance(run_number, test_env, uni, jit, initial_regs, instruction_count, instructions_to_execute_count); + } +} + +void FuzzJitThumb32(const size_t instruction_count, const size_t instructions_to_execute_count, const size_t run_count, const std::function<u32()> instruction_generator) { + ThumbTestEnv test_env; + + // Prepare memory. + // A Thumb-32 instruction is 32-bits so we multiply our count + test_env.code_mem.resize(instruction_count * 2 + 1); + test_env.code_mem.back() = 0xE7FE; // b +#0 + + // Prepare test subjects + A32Unicorn uni{test_env}; + A32::Jit jit{GetUserConfig(&test_env)}; + + for (size_t run_number = 0; run_number < run_count; run_number++) { + ThumbTestEnv::RegisterArray initial_regs; + std::generate_n(initial_regs.begin(), initial_regs.size() - 1, [] { return RandInt<u32>(0, 0xFFFFFFFF); }); + initial_regs[15] = 0; + + for (size_t i = 0; i < instruction_count; i++) { + const auto instruction = instruction_generator(); + const auto first_halfword = static_cast<u16>(mcl::bit::get_bits<0, 15>(instruction)); + const auto second_halfword = static_cast<u16>(mcl::bit::get_bits<16, 31>(instruction)); + + test_env.code_mem[i * 2 + 0] = second_halfword; + test_env.code_mem[i * 2 + 1] = first_halfword; + } + + RunInstance(run_number, test_env, uni, jit, initial_regs, instruction_count, instructions_to_execute_count); + } +} + +TEST_CASE("Fuzz Thumb instructions set 1", "[JitX64][Thumb][Thumb16]") { + const std::array instructions = { + ThumbInstGen("00000xxxxxxxxxxx"), // LSL <Rd>, <Rm>, #<imm5> + ThumbInstGen("00001xxxxxxxxxxx"), // LSR <Rd>, <Rm>, #<imm5> + ThumbInstGen("00010xxxxxxxxxxx"), // ASR <Rd>, <Rm>, #<imm5> + ThumbInstGen("000110oxxxxxxxxx"), // ADD/SUB_reg + ThumbInstGen("000111oxxxxxxxxx"), // ADD/SUB_imm + ThumbInstGen("001ooxxxxxxxxxxx"), // ADD/SUB/CMP/MOV_imm + ThumbInstGen("010000ooooxxxxxx"), // Data Processing + ThumbInstGen("010001000hxxxxxx"), // ADD (high registers) + ThumbInstGen("0100010101xxxxxx", // CMP (high registers) + [](u32 inst) { return mcl::bit::get_bits<3, 5>(inst) != 0b111; }), // R15 is UNPREDICTABLE + ThumbInstGen("0100010110xxxxxx", // CMP (high registers) + [](u32 inst) { return mcl::bit::get_bits<0, 2>(inst) != 0b111; }), // R15 is UNPREDICTABLE + ThumbInstGen("010001100hxxxxxx"), // MOV (high registers) + ThumbInstGen("10110000oxxxxxxx"), // Adjust stack pointer + ThumbInstGen("10110010ooxxxxxx"), // SXT/UXT + ThumbInstGen("1011101000xxxxxx"), // REV + ThumbInstGen("1011101001xxxxxx"), // REV16 + ThumbInstGen("1011101011xxxxxx"), // REVSH + ThumbInstGen("01001xxxxxxxxxxx"), // LDR Rd, [PC, #] + ThumbInstGen("0101oooxxxxxxxxx"), // LDR/STR Rd, [Rn, Rm] + ThumbInstGen("011xxxxxxxxxxxxx"), // LDR(B)/STR(B) Rd, [Rn, #] + ThumbInstGen("1000xxxxxxxxxxxx"), // LDRH/STRH Rd, [Rn, #offset] + ThumbInstGen("1001xxxxxxxxxxxx"), // LDR/STR Rd, [SP, #] + ThumbInstGen("1011010xxxxxxxxx", // PUSH + [](u32 inst) { return mcl::bit::get_bits<0, 7>(inst) != 0; }), // Empty reg_list is UNPREDICTABLE + ThumbInstGen("10111100xxxxxxxx", // POP (P = 0) + [](u32 inst) { return mcl::bit::get_bits<0, 7>(inst) != 0; }), // Empty reg_list is UNPREDICTABLE + ThumbInstGen("1100xxxxxxxxxxxx", // STMIA/LDMIA + [](u32 inst) { + // Ensure that the architecturally undefined case of + // the base register being within the list isn't hit. + const u32 rn = mcl::bit::get_bits<8, 10>(inst); + return (inst & (1U << rn)) == 0 && mcl::bit::get_bits<0, 7>(inst) != 0; + }), + // TODO: We should properly test against swapped + // endianness cases, however Unicorn doesn't + // expose the intended endianness of a load/store + // operation to memory through its hooks. +#if 0 + ThumbInstGen("101101100101x000"), // SETEND +#endif + }; + + const auto instruction_select = [&]() -> u16 { + const auto inst_index = RandInt<size_t>(0, instructions.size() - 1); + + return instructions[inst_index].Generate16(); + }; + + SECTION("single instructions") { + FuzzJitThumb16(1, 2, 10000, instruction_select); + } + + SECTION("short blocks") { + FuzzJitThumb16(5, 6, 3000, instruction_select); + } + + // TODO: Test longer blocks when Unicorn can consistently + // run these without going into an infinite loop. +#if 0 + SECTION("long blocks") { + FuzzJitThumb16(1024, 1025, 1000, instruction_select); + } +#endif +} + +TEST_CASE("Fuzz Thumb instructions set 2 (affects PC)", "[JitX64][Thumb][Thumb16]") { + const std::array instructions = { + // TODO: We currently can't test BX/BLX as we have + // no way of preventing the unpredictable + // condition from occurring with the current interface. + // (bits zero and one within the specified register + // must not be address<1:0> == '10'. +#if 0 + ThumbInstGen("01000111xmmmm000", // BLX/BX + [](u32 inst){ + const u32 Rm = mcl::bit::get_bits<3, 6>(inst); + return Rm != 15; + }), +#endif + ThumbInstGen("1010oxxxxxxxxxxx"), // add to pc/sp + ThumbInstGen("11100xxxxxxxxxxx"), // B + ThumbInstGen("01000100h0xxxxxx"), // ADD (high registers) + ThumbInstGen("01000110h0xxxxxx"), // MOV (high registers) + ThumbInstGen("1101ccccxxxxxxxx", // B<cond> + [](u32 inst) { + const u32 c = mcl::bit::get_bits<9, 12>(inst); + return c < 0b1110; // Don't want SWI or undefined instructions. + }), + ThumbInstGen("1011o0i1iiiiinnn"), // CBZ/CBNZ + ThumbInstGen("10110110011x0xxx"), // CPS + + // TODO: We currently have no control over the generated + // values when creating new pages, so we can't + // reliably test this yet. +#if 0 + ThumbInstGen("10111101xxxxxxxx"), // POP (R = 1) +#endif + }; + + const auto instruction_select = [&]() -> u16 { + const auto inst_index = RandInt<size_t>(0, instructions.size() - 1); + + return instructions[inst_index].Generate16(); + }; + + FuzzJitThumb16(1, 1, 10000, instruction_select); +} + +TEST_CASE("Fuzz Thumb32 instructions set", "[JitX64][Thumb][Thumb32]") { + const auto three_reg_not_r15 = [](u32 inst) { + const auto d = mcl::bit::get_bits<8, 11>(inst); + const auto m = mcl::bit::get_bits<0, 3>(inst); + const auto n = mcl::bit::get_bits<16, 19>(inst); + return d != 15 && m != 15 && n != 15; + }; + + const std::array instructions = { + ThumbInstGen("111110101011nnnn1111dddd1000mmmm", // CLZ + [](u32 inst) { + const auto d = mcl::bit::get_bits<8, 11>(inst); + const auto m = mcl::bit::get_bits<0, 3>(inst); + const auto n = mcl::bit::get_bits<16, 19>(inst); + return m == n && d != 15 && m != 15; + }), + ThumbInstGen("111110101000nnnn1111dddd1000mmmm", // QADD + three_reg_not_r15), + ThumbInstGen("111110101000nnnn1111dddd0001mmmm", // QADD8 + three_reg_not_r15), + ThumbInstGen("111110101001nnnn1111dddd0001mmmm", // QADD16 + three_reg_not_r15), + ThumbInstGen("111110101010nnnn1111dddd0001mmmm", // QASX + three_reg_not_r15), + ThumbInstGen("111110101000nnnn1111dddd1001mmmm", // QDADD + three_reg_not_r15), + ThumbInstGen("111110101000nnnn1111dddd1011mmmm", // QDSUB + three_reg_not_r15), + ThumbInstGen("111110101110nnnn1111dddd0001mmmm", // QSAX + three_reg_not_r15), + ThumbInstGen("111110101000nnnn1111dddd1010mmmm", // QSUB + three_reg_not_r15), + ThumbInstGen("111110101100nnnn1111dddd0001mmmm", // QSUB8 + three_reg_not_r15), + ThumbInstGen("111110101101nnnn1111dddd0001mmmm", // QSUB16 + three_reg_not_r15), + ThumbInstGen("111110101001nnnn1111dddd1010mmmm", // RBIT + [](u32 inst) { + const auto d = mcl::bit::get_bits<8, 11>(inst); + const auto m = mcl::bit::get_bits<0, 3>(inst); + const auto n = mcl::bit::get_bits<16, 19>(inst); + return m == n && d != 15 && m != 15; + }), + ThumbInstGen("111110101001nnnn1111dddd1000mmmm", // REV + [](u32 inst) { + const auto d = mcl::bit::get_bits<8, 11>(inst); + const auto m = mcl::bit::get_bits<0, 3>(inst); + const auto n = mcl::bit::get_bits<16, 19>(inst); + return m == n && d != 15 && m != 15; + }), + ThumbInstGen("111110101001nnnn1111dddd1001mmmm", // REV16 + [](u32 inst) { + const auto d = mcl::bit::get_bits<8, 11>(inst); + const auto m = mcl::bit::get_bits<0, 3>(inst); + const auto n = mcl::bit::get_bits<16, 19>(inst); + return m == n && d != 15 && m != 15; + }), + ThumbInstGen("111110101001nnnn1111dddd1011mmmm", // REVSH + [](u32 inst) { + const auto d = mcl::bit::get_bits<8, 11>(inst); + const auto m = mcl::bit::get_bits<0, 3>(inst); + const auto n = mcl::bit::get_bits<16, 19>(inst); + return m == n && d != 15 && m != 15; + }), + ThumbInstGen("111110101000nnnn1111dddd0000mmmm", // SADD8 + three_reg_not_r15), + ThumbInstGen("111110101001nnnn1111dddd0000mmmm", // SADD16 + three_reg_not_r15), + ThumbInstGen("111110101010nnnn1111dddd0000mmmm", // SASX + three_reg_not_r15), + ThumbInstGen("111110101010nnnn1111dddd1000mmmm", // SEL + three_reg_not_r15), + ThumbInstGen("111110101000nnnn1111dddd0010mmmm", // SHADD8 + three_reg_not_r15), + ThumbInstGen("111110101001nnnn1111dddd0010mmmm", // SHADD16 + three_reg_not_r15), + ThumbInstGen("111110101010nnnn1111dddd0010mmmm", // SHASX + three_reg_not_r15), + ThumbInstGen("111110101110nnnn1111dddd0010mmmm", // SHSAX + three_reg_not_r15), + ThumbInstGen("111110101100nnnn1111dddd0010mmmm", // SHSUB8 + three_reg_not_r15), + ThumbInstGen("111110101101nnnn1111dddd0010mmmm", // SHSUB16 + three_reg_not_r15), + ThumbInstGen("111110101110nnnn1111dddd0000mmmm", // SSAX + three_reg_not_r15), + ThumbInstGen("111110101100nnnn1111dddd0000mmmm", // SSUB8 + three_reg_not_r15), + ThumbInstGen("111110101101nnnn1111dddd0000mmmm", // SSUB16 + three_reg_not_r15), + ThumbInstGen("111110101000nnnn1111dddd0100mmmm", // UADD8 + three_reg_not_r15), + ThumbInstGen("111110101001nnnn1111dddd0100mmmm", // UADD16 + three_reg_not_r15), + ThumbInstGen("111110101010nnnn1111dddd0100mmmm", // UASX + three_reg_not_r15), + ThumbInstGen("111110101000nnnn1111dddd0110mmmm", // UHADD8 + three_reg_not_r15), + ThumbInstGen("111110101001nnnn1111dddd0110mmmm", // UHADD16 + three_reg_not_r15), + ThumbInstGen("111110101010nnnn1111dddd0110mmmm", // UHASX + three_reg_not_r15), + ThumbInstGen("111110101110nnnn1111dddd0110mmmm", // UHSAX + three_reg_not_r15), + ThumbInstGen("111110101100nnnn1111dddd0110mmmm", // UHSUB8 + three_reg_not_r15), + ThumbInstGen("111110101101nnnn1111dddd0110mmmm", // UHSUB16 + three_reg_not_r15), + ThumbInstGen("111110101000nnnn1111dddd0101mmmm", // UQADD8 + three_reg_not_r15), + ThumbInstGen("111110101001nnnn1111dddd0101mmmm", // UQADD16 + three_reg_not_r15), + ThumbInstGen("111110101010nnnn1111dddd0101mmmm", // UQASX + three_reg_not_r15), + ThumbInstGen("111110101110nnnn1111dddd0101mmmm", // UQSAX + three_reg_not_r15), + ThumbInstGen("111110101100nnnn1111dddd0101mmmm", // UQSUB8 + three_reg_not_r15), + ThumbInstGen("111110101101nnnn1111dddd0101mmmm", // UQSUB16 + three_reg_not_r15), + ThumbInstGen("111110101110nnnn1111dddd0100mmmm", // USAX + three_reg_not_r15), + ThumbInstGen("111110101100nnnn1111dddd0100mmmm", // USUB8 + three_reg_not_r15), + ThumbInstGen("111110101101nnnn1111dddd0100mmmm", // USUB16 + three_reg_not_r15), + }; + + const auto instruction_select = [&]() -> u32 { + const auto inst_index = RandInt<size_t>(0, instructions.size() - 1); + + return instructions[inst_index].Generate32(); + }; + + SECTION("single instructions") { + FuzzJitThumb32(1, 2, 10000, instruction_select); + } + + SECTION("short blocks") { + FuzzJitThumb32(5, 6, 3000, instruction_select); + } +} + +TEST_CASE("Verify fix for off by one error in MemoryRead32 worked", "[Thumb][Thumb16]") { + ThumbTestEnv test_env; + + // Prepare test subjects + A32Unicorn<ThumbTestEnv> uni{test_env}; + A32::Jit jit{GetUserConfig(&test_env)}; + + constexpr ThumbTestEnv::RegisterArray initial_regs{ + 0xe90ecd70, + 0x3e3b73c3, + 0x571616f9, + 0x0b1ef45a, + 0xb3a829f2, + 0x915a7a6a, + 0x579c38f4, + 0xd9ffe391, + 0x55b6682b, + 0x458d8f37, + 0x8f3eb3dc, + 0xe18c0e7d, + 0x6752657a, + 0x00001766, + 0xdbbf23e3, + 0x00000000, + }; + + test_env.code_mem = { + 0x40B8, // lsls r0, r7, #0 + 0x01CA, // lsls r2, r1, #7 + 0x83A1, // strh r1, [r4, #28] + 0x708A, // strb r2, [r1, #2] + 0xBCC4, // pop {r2, r6, r7} + 0xE7FE, // b +#0 + }; + + RunInstance(1, test_env, uni, jit, initial_regs, 5, 5); +} diff --git a/externals/dynarmic/tests/A32/test_arm_disassembler.cpp b/externals/dynarmic/tests/A32/test_arm_disassembler.cpp new file mode 100644 index 0000000000..5cefc0be46 --- /dev/null +++ b/externals/dynarmic/tests/A32/test_arm_disassembler.cpp @@ -0,0 +1,381 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2016 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <catch2/catch_test_macros.hpp> + +#include "dynarmic/frontend/A32/disassembler/disassembler.h" + +using Dynarmic::A32::DisassembleArm; + +TEST_CASE("Disassemble branch instructions", "[arm][disassembler]") { + REQUIRE(DisassembleArm(0xEAFFFFFE) == "b +#0"); + REQUIRE(DisassembleArm(0xEB000008) == "bl +#40"); + REQUIRE(DisassembleArm(0xFBFFFFFE) == "blx +#2"); + REQUIRE(DisassembleArm(0xFAFFFFFF) == "blx +#4"); + REQUIRE(DisassembleArm(0xFBE1E7FE) == "blx -#7888894"); + REQUIRE(DisassembleArm(0xE12FFF3D) == "blx sp"); + REQUIRE(DisassembleArm(0x312FFF13) == "bxcc r3"); + REQUIRE(DisassembleArm(0x012FFF29) == "bxjeq r9"); +} + +TEST_CASE("Disassemble data processing instructions", "[arm][disassembler]") { + REQUIRE(DisassembleArm(0xE2A21004) == "adc r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0A21143) == "adc r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0A21103) == "adc r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0A21123) == "adc r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0A21163) == "adc r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0A21003) == "adc r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0A21063) == "adc r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE0A21453) == "adc r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0A21413) == "adc r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0A21433) == "adc r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0A21473) == "adc r1, r2, r3, ror r4"); + REQUIRE(DisassembleArm(0xE2B21004) == "adcs r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0B21143) == "adcs r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0B21103) == "adcs r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0B21123) == "adcs r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0B21163) == "adcs r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0B21003) == "adcs r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0B21063) == "adcs r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE0B21453) == "adcs r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0B21413) == "adcs r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0B21433) == "adcs r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0B21473) == "adcs r1, r2, r3, ror r4"); + + REQUIRE(DisassembleArm(0xE2853004) == "add r3, r5, #4"); + REQUIRE(DisassembleArm(0xE0821143) == "add r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0821103) == "add r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0821123) == "add r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0821163) == "add r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0821003) == "add r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0821453) == "add r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0821413) == "add r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0821433) == "add r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0821473) == "add r1, r2, r3, ror r4"); + REQUIRE(DisassembleArm(0xE0821063) == "add r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE2953004) == "adds r3, r5, #4"); + REQUIRE(DisassembleArm(0xE0921143) == "adds r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0921103) == "adds r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0921123) == "adds r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0921163) == "adds r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0921003) == "adds r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0921063) == "adds r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE0921453) == "adds r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0921413) == "adds r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0921433) == "adds r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0921473) == "adds r1, r2, r3, ror r4"); + + REQUIRE(DisassembleArm(0xE2021004) == "and r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0021143) == "and r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0021103) == "and r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0021123) == "and r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0021163) == "and r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0021003) == "and r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0021453) == "and r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0021413) == "and r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0021433) == "and r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0021473) == "and r1, r2, r3, ror r4"); + REQUIRE(DisassembleArm(0xE0021063) == "and r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE2121004) == "ands r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0121143) == "ands r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0121103) == "ands r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0121123) == "ands r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0121163) == "ands r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0121003) == "ands r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0121063) == "ands r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE0121453) == "ands r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0121413) == "ands r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0121433) == "ands r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0121473) == "ands r1, r2, r3, ror r4"); + + REQUIRE(DisassembleArm(0xE3C21004) == "bic r1, r2, #4"); + REQUIRE(DisassembleArm(0xE1C21143) == "bic r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE1C21103) == "bic r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE1C21123) == "bic r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE1C21163) == "bic r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE1C21003) == "bic r1, r2, r3"); + REQUIRE(DisassembleArm(0xE1C21453) == "bic r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE1C21413) == "bic r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE1C21433) == "bic r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE1C21473) == "bic r1, r2, r3, ror r4"); + REQUIRE(DisassembleArm(0xE1C21063) == "bic r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE3D21004) == "bics r1, r2, #4"); + REQUIRE(DisassembleArm(0xE1D21143) == "bics r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE1D21103) == "bics r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE1D21123) == "bics r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE1D21163) == "bics r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE1D21003) == "bics r1, r2, r3"); + REQUIRE(DisassembleArm(0xE1D21063) == "bics r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE1D21453) == "bics r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE1D21413) == "bics r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE1D21433) == "bics r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE1D21473) == "bics r1, r2, r3, ror r4"); + + REQUIRE(DisassembleArm(0xE3710004) == "cmn r1, #4"); + REQUIRE(DisassembleArm(0xE1710142) == "cmn r1, r2, asr #2"); + REQUIRE(DisassembleArm(0xE1710102) == "cmn r1, r2, lsl #2"); + REQUIRE(DisassembleArm(0xE1710122) == "cmn r1, r2, lsr #2"); + REQUIRE(DisassembleArm(0xE1710162) == "cmn r1, r2, ror #2"); + REQUIRE(DisassembleArm(0xE1710002) == "cmn r1, r2"); + REQUIRE(DisassembleArm(0xE1710062) == "cmn r1, r2, rrx"); + REQUIRE(DisassembleArm(0xE1710352) == "cmn r1, r2, asr r3"); + REQUIRE(DisassembleArm(0xE1710312) == "cmn r1, r2, lsl r3"); + REQUIRE(DisassembleArm(0xE1710332) == "cmn r1, r2, lsr r3"); + REQUIRE(DisassembleArm(0xE1710372) == "cmn r1, r2, ror r3"); + + REQUIRE(DisassembleArm(0xE3510004) == "cmp r1, #4"); + REQUIRE(DisassembleArm(0xE1510142) == "cmp r1, r2, asr #2"); + REQUIRE(DisassembleArm(0xE1510102) == "cmp r1, r2, lsl #2"); + REQUIRE(DisassembleArm(0xE1510122) == "cmp r1, r2, lsr #2"); + REQUIRE(DisassembleArm(0xE1510162) == "cmp r1, r2, ror #2"); + REQUIRE(DisassembleArm(0xE1510002) == "cmp r1, r2"); + REQUIRE(DisassembleArm(0xE1510062) == "cmp r1, r2, rrx"); + REQUIRE(DisassembleArm(0xE1510352) == "cmp r1, r2, asr r3"); + REQUIRE(DisassembleArm(0xE1510312) == "cmp r1, r2, lsl r3"); + REQUIRE(DisassembleArm(0xE1510332) == "cmp r1, r2, lsr r3"); + REQUIRE(DisassembleArm(0xE1510372) == "cmp r1, r2, ror r3"); + + REQUIRE(DisassembleArm(0xE2221004) == "eor r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0221243) == "eor r1, r2, r3, asr #4"); + REQUIRE(DisassembleArm(0xE0221203) == "eor r1, r2, r3, lsl #4"); + REQUIRE(DisassembleArm(0xE0221223) == "eor r1, r2, r3, lsr #4"); + REQUIRE(DisassembleArm(0xE0221263) == "eor r1, r2, r3, ror #4"); + REQUIRE(DisassembleArm(0xE0221003) == "eor r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0221453) == "eor r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0221413) == "eor r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0221433) == "eor r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0221473) == "eor r1, r2, r3, ror r4"); + REQUIRE(DisassembleArm(0xE0221063) == "eor r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE2321004) == "eors r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0321243) == "eors r1, r2, r3, asr #4"); + REQUIRE(DisassembleArm(0xE0321203) == "eors r1, r2, r3, lsl #4"); + REQUIRE(DisassembleArm(0xE0321223) == "eors r1, r2, r3, lsr #4"); + REQUIRE(DisassembleArm(0xE0321263) == "eors r1, r2, r3, ror #4"); + REQUIRE(DisassembleArm(0xE0321003) == "eors r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0321453) == "eors r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0321413) == "eors r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0321433) == "eors r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0321473) == "eors r1, r2, r3, ror r4"); + REQUIRE(DisassembleArm(0xE0321063) == "eors r1, r2, r3, rrx"); + + REQUIRE(DisassembleArm(0xE3A010FF) == "mov r1, #255"); + REQUIRE(DisassembleArm(0xE1A01142) == "mov r1, r2, asr #2"); + REQUIRE(DisassembleArm(0xE1A01102) == "mov r1, r2, lsl #2"); + REQUIRE(DisassembleArm(0xE1A01122) == "mov r1, r2, lsr #2"); + REQUIRE(DisassembleArm(0xE1A01162) == "mov r1, r2, ror #2"); + REQUIRE(DisassembleArm(0xE1A01062) == "mov r1, r2, rrx"); + REQUIRE(DisassembleArm(0xE1A0E00F) == "mov lr, pc"); + REQUIRE(DisassembleArm(0xE3B010FF) == "movs r1, #255"); + REQUIRE(DisassembleArm(0xE1B0E00F) == "movs lr, pc"); + REQUIRE(DisassembleArm(0xE1B01142) == "movs r1, r2, asr #2"); + REQUIRE(DisassembleArm(0xE1B01102) == "movs r1, r2, lsl #2"); + REQUIRE(DisassembleArm(0xE1B01122) == "movs r1, r2, lsr #2"); + REQUIRE(DisassembleArm(0xE1B01162) == "movs r1, r2, ror #2"); + + REQUIRE(DisassembleArm(0xE3E01004) == "mvn r1, #4"); + REQUIRE(DisassembleArm(0xE1E01142) == "mvn r1, r2, asr #2"); + REQUIRE(DisassembleArm(0xE1E01102) == "mvn r1, r2, lsl #2"); + REQUIRE(DisassembleArm(0xE1E01122) == "mvn r1, r2, lsr #2"); + REQUIRE(DisassembleArm(0xE1E01162) == "mvn r1, r2, ror #2"); + REQUIRE(DisassembleArm(0xE1E01062) == "mvn r1, r2, rrx"); + REQUIRE(DisassembleArm(0xE1E01002) == "mvn r1, r2"); + REQUIRE(DisassembleArm(0xE1E01352) == "mvn r1, r2, asr r3"); + REQUIRE(DisassembleArm(0xE1E01312) == "mvn r1, r2, lsl r3"); + REQUIRE(DisassembleArm(0xE1E01332) == "mvn r1, r2, lsr r3"); + REQUIRE(DisassembleArm(0xE1E01372) == "mvn r1, r2, ror r3"); + REQUIRE(DisassembleArm(0xE3F01004) == "mvns r1, #4"); + REQUIRE(DisassembleArm(0xE1F01142) == "mvns r1, r2, asr #2"); + REQUIRE(DisassembleArm(0xE1F01102) == "mvns r1, r2, lsl #2"); + REQUIRE(DisassembleArm(0xE1F01122) == "mvns r1, r2, lsr #2"); + REQUIRE(DisassembleArm(0xE1F01162) == "mvns r1, r2, ror #2"); + REQUIRE(DisassembleArm(0xE1F01062) == "mvns r1, r2, rrx"); + REQUIRE(DisassembleArm(0xE1F01002) == "mvns r1, r2"); + REQUIRE(DisassembleArm(0xE1F01352) == "mvns r1, r2, asr r3"); + REQUIRE(DisassembleArm(0xE1F01312) == "mvns r1, r2, lsl r3"); + REQUIRE(DisassembleArm(0xE1F01332) == "mvns r1, r2, lsr r3"); + REQUIRE(DisassembleArm(0xE1F01372) == "mvns r1, r2, ror r3"); + + REQUIRE(DisassembleArm(0xE3821004) == "orr r1, r2, #4"); + REQUIRE(DisassembleArm(0xE1821143) == "orr r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE1821103) == "orr r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE1821123) == "orr r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE1821163) == "orr r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE1821063) == "orr r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE1821003) == "orr r1, r2, r3"); + REQUIRE(DisassembleArm(0xE1821453) == "orr r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE1821413) == "orr r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE1821433) == "orr r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE1821473) == "orr r1, r2, r3, ror r4"); + REQUIRE(DisassembleArm(0xE3921004) == "orrs r1, r2, #4"); + REQUIRE(DisassembleArm(0xE1921143) == "orrs r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE1921103) == "orrs r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE1921123) == "orrs r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE1921163) == "orrs r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE1921063) == "orrs r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE1921003) == "orrs r1, r2, r3"); + REQUIRE(DisassembleArm(0xE1921453) == "orrs r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE1921413) == "orrs r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE1921433) == "orrs r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE1921473) == "orrs r1, r2, r3, ror r4"); + + REQUIRE(DisassembleArm(0xE2621004) == "rsb r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0621143) == "rsb r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0621103) == "rsb r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0621123) == "rsb r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0621163) == "rsb r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0621063) == "rsb r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE0621003) == "rsb r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0621453) == "rsb r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0621413) == "rsb r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0621433) == "rsb r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0621473) == "rsb r1, r2, r3, ror r4"); + REQUIRE(DisassembleArm(0xE2721004) == "rsbs r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0721143) == "rsbs r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0721103) == "rsbs r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0721123) == "rsbs r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0721163) == "rsbs r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0721063) == "rsbs r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE0721003) == "rsbs r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0721453) == "rsbs r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0721413) == "rsbs r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0721433) == "rsbs r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0721473) == "rsbs r1, r2, r3, ror r4"); + + REQUIRE(DisassembleArm(0xE2E21004) == "rsc r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0E21143) == "rsc r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0E21103) == "rsc r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0E21123) == "rsc r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0E21163) == "rsc r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0E21063) == "rsc r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE0E21003) == "rsc r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0E21453) == "rsc r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0E21413) == "rsc r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0E21433) == "rsc r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0E21473) == "rsc r1, r2, r3, ror r4"); + REQUIRE(DisassembleArm(0xE2F21004) == "rscs r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0F21143) == "rscs r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0F21103) == "rscs r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0F21123) == "rscs r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0F21163) == "rscs r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0F21063) == "rscs r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE0F21003) == "rscs r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0F21453) == "rscs r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0F21413) == "rscs r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0F21433) == "rscs r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0F21473) == "rscs r1, r2, r3, ror r4"); + + REQUIRE(DisassembleArm(0xE2C21004) == "sbc r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0C21143) == "sbc r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0C21103) == "sbc r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0C21123) == "sbc r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0C21163) == "sbc r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0C21063) == "sbc r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE0C21003) == "sbc r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0C21453) == "sbc r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0C21413) == "sbc r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0C21433) == "sbc r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0C21473) == "sbc r1, r2, r3, ror r4"); + REQUIRE(DisassembleArm(0xE2D21004) == "sbcs r1, r2, #4"); + REQUIRE(DisassembleArm(0xE0D21143) == "sbcs r1, r2, r3, asr #2"); + REQUIRE(DisassembleArm(0xE0D21103) == "sbcs r1, r2, r3, lsl #2"); + REQUIRE(DisassembleArm(0xE0D21123) == "sbcs r1, r2, r3, lsr #2"); + REQUIRE(DisassembleArm(0xE0D21163) == "sbcs r1, r2, r3, ror #2"); + REQUIRE(DisassembleArm(0xE0D21063) == "sbcs r1, r2, r3, rrx"); + REQUIRE(DisassembleArm(0xE0D21003) == "sbcs r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0D21453) == "sbcs r1, r2, r3, asr r4"); + REQUIRE(DisassembleArm(0xE0D21413) == "sbcs r1, r2, r3, lsl r4"); + REQUIRE(DisassembleArm(0xE0D21433) == "sbcs r1, r2, r3, lsr r4"); + REQUIRE(DisassembleArm(0xE0D21473) == "sbcs r1, r2, r3, ror r4"); + + REQUIRE(DisassembleArm(0xE3310004) == "teq r1, #4"); + REQUIRE(DisassembleArm(0xE1310142) == "teq r1, r2, asr #2"); + REQUIRE(DisassembleArm(0xE1310102) == "teq r1, r2, lsl #2"); + REQUIRE(DisassembleArm(0xE1310122) == "teq r1, r2, lsr #2"); + REQUIRE(DisassembleArm(0xE1310162) == "teq r1, r2, ror #2"); + REQUIRE(DisassembleArm(0xE1310002) == "teq r1, r2"); + REQUIRE(DisassembleArm(0xE1310062) == "teq r1, r2, rrx"); + REQUIRE(DisassembleArm(0xE1310352) == "teq r1, r2, asr r3"); + REQUIRE(DisassembleArm(0xE1310312) == "teq r1, r2, lsl r3"); + REQUIRE(DisassembleArm(0xE1310332) == "teq r1, r2, lsr r3"); + REQUIRE(DisassembleArm(0xE1310372) == "teq r1, r2, ror r3"); + + REQUIRE(DisassembleArm(0xE3110004) == "tst r1, #4"); + REQUIRE(DisassembleArm(0xE1110142) == "tst r1, r2, asr #2"); + REQUIRE(DisassembleArm(0xE1110102) == "tst r1, r2, lsl #2"); + REQUIRE(DisassembleArm(0xE1110122) == "tst r1, r2, lsr #2"); + REQUIRE(DisassembleArm(0xE1110162) == "tst r1, r2, ror #2"); + REQUIRE(DisassembleArm(0xE1110002) == "tst r1, r2"); + REQUIRE(DisassembleArm(0xE1110062) == "tst r1, r2, rrx"); + REQUIRE(DisassembleArm(0xE1110352) == "tst r1, r2, asr r3"); + REQUIRE(DisassembleArm(0xE1110312) == "tst r1, r2, lsl r3"); + REQUIRE(DisassembleArm(0xE1110332) == "tst r1, r2, lsr r3"); + REQUIRE(DisassembleArm(0xE1110372) == "tst r1, r2, ror r3"); +} + +TEST_CASE("Disassemble half-word multiply and multiply accumulate instructions", "[arm][disassembler]") { + REQUIRE(DisassembleArm(0xE1003281) == "smlabb r0, r1, r2, r3"); + REQUIRE(DisassembleArm(0xE10032C1) == "smlabt r0, r1, r2, r3"); + REQUIRE(DisassembleArm(0xE10032A1) == "smlatb r0, r1, r2, r3"); + REQUIRE(DisassembleArm(0xE10032E1) == "smlatt r0, r1, r2, r3"); + + REQUIRE(DisassembleArm(0xE1203281) == "smlawb r0, r1, r2, r3"); + REQUIRE(DisassembleArm(0xE12032C1) == "smlawt r0, r1, r2, r3"); + + REQUIRE(DisassembleArm(0xE12002A1) == "smulwb r0, r1, r2"); + REQUIRE(DisassembleArm(0xE12002E1) == "smulwt r0, r1, r2"); + + REQUIRE(DisassembleArm(0xE1410382) == "smlalbb r0, r1, r2, r3"); + REQUIRE(DisassembleArm(0xE14103C2) == "smlalbt r0, r1, r2, r3"); + REQUIRE(DisassembleArm(0xE14103A2) == "smlaltb r0, r1, r2, r3"); + REQUIRE(DisassembleArm(0xE14103E2) == "smlaltt r0, r1, r2, r3"); + + REQUIRE(DisassembleArm(0xE1600281) == "smulbb r0, r1, r2"); + REQUIRE(DisassembleArm(0xE16002C1) == "smulbt r0, r1, r2"); + REQUIRE(DisassembleArm(0xE16002A1) == "smultb r0, r1, r2"); + REQUIRE(DisassembleArm(0xE16002E1) == "smultt r0, r1, r2"); +} + +TEST_CASE("Disassemble multiply and multiply accumulate instructions", "[arm][disassembler]") { + REQUIRE(DisassembleArm(0xE0214392) == "mla r1, r2, r3, r4"); + REQUIRE(DisassembleArm(0xE0314392) == "mlas r1, r2, r3, r4"); + + REQUIRE(DisassembleArm(0xE0010392) == "mul r1, r2, r3"); + REQUIRE(DisassembleArm(0xE0110392) == "muls r1, r2, r3"); + + // TODO: MLS should be here whenever it's supported. + + REQUIRE(DisassembleArm(0xE0E21493) == "smlal r1, r2, r3, r4"); + REQUIRE(DisassembleArm(0xE0F21493) == "smlals r1, r2, r3, r4"); + + REQUIRE(DisassembleArm(0xE0C21493) == "smull r1, r2, r3, r4"); + REQUIRE(DisassembleArm(0xE0D21493) == "smulls r1, r2, r3, r4"); + + REQUIRE(DisassembleArm(0xE0421493) == "umaal r1, r2, r3, r4"); + + REQUIRE(DisassembleArm(0xE0A21493) == "umlal r1, r2, r3, r4"); + REQUIRE(DisassembleArm(0xE0B21493) == "umlals r1, r2, r3, r4"); + + REQUIRE(DisassembleArm(0xE0821493) == "umull r1, r2, r3, r4"); + REQUIRE(DisassembleArm(0xE0921493) == "umulls r1, r2, r3, r4"); +} + +TEST_CASE("Disassemble synchronization primitive instructions", "[arm][disassembler]") { + REQUIRE(DisassembleArm(0xE1921F9F) == "ldrex r1, [r2]"); + REQUIRE(DisassembleArm(0xE1D21F9F) == "ldrexb r1, [r2]"); + REQUIRE(DisassembleArm(0xE1B31F9F) == "ldrexd r1, r2, [r3]"); + REQUIRE(DisassembleArm(0xE1F21F9F) == "ldrexh r1, [r2]"); + + REQUIRE(DisassembleArm(0xE1831F92) == "strex r1, r2, [r3]"); + REQUIRE(DisassembleArm(0xE1C31F92) == "strexb r1, r2, [r3]"); + REQUIRE(DisassembleArm(0xE1A41F92) == "strexd r1, r2, r3, [r4]"); + REQUIRE(DisassembleArm(0xE1E31F92) == "strexh r1, r2, [r3]"); + + REQUIRE(DisassembleArm(0xE1031092) == "swp r1, r2, [r3]"); + REQUIRE(DisassembleArm(0xE1431092) == "swpb r1, r2, [r3]"); +} + +TEST_CASE("Disassemble load / store multiple instructions", "[arm][disassembler]") { + REQUIRE(DisassembleArm(0xE92D500F) == "stmdb sp!, {r0, r1, r2, r3, r12, lr}"); +} diff --git a/externals/dynarmic/tests/A32/test_arm_instructions.cpp b/externals/dynarmic/tests/A32/test_arm_instructions.cpp new file mode 100644 index 0000000000..b4a173312c --- /dev/null +++ b/externals/dynarmic/tests/A32/test_arm_instructions.cpp @@ -0,0 +1,704 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2016 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <catch2/catch_test_macros.hpp> + +#include "./testenv.h" +#include "dynarmic/frontend/A32/a32_location_descriptor.h" +#include "dynarmic/interface/A32/a32.h" + +using namespace Dynarmic; + +static A32::UserConfig GetUserConfig(ArmTestEnv* testenv) { + A32::UserConfig user_config; + user_config.optimizations &= ~OptimizationFlag::FastDispatch; + user_config.callbacks = testenv; + return user_config; +} + +TEST_CASE("arm: Opt Failure: Const folding in MostSignificantWord", "[arm][A32]") { + // This was a randomized test-case that was failing. + // This was due to constant folding for MostSignificantWord + // failing to take into account an associated GetCarryFromOp + // pseudoinstruction. + + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xe30ad071, // movw, sp, #41073 + 0xe75efd3d, // smmulr lr, sp, sp + 0xa637af1e, // shadd16ge r10, r7, lr + 0xf57ff01f, // clrex + 0x86b98879, // sxtahhi r8, r9, r9, ror #16 + 0xeafffffe, // b +#0 + }; + + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 6; + jit.Run(); + + // If we don't trigger the GetCarryFromOp ASSERT, we're fine. +} + +TEST_CASE("arm: Unintended modification in SetCFlag", "[arm][A32]") { + // This was a randomized test-case that was failing. + // + // IR produced for location {12, !T, !E} was: + // %0 = GetRegister r1 + // %1 = SubWithCarry %0, #0x3e80000, #1 + // %2 = GetCarryFromOp %1 + // %3 = GetOverflowFromOp %1 + // %4 = MostSignificantBit %1 + // SetNFlag %4 + // %6 = IsZero %1 + // SetZFlag %6 + // SetCFlag %2 + // SetVFlag %3 + // %10 = GetRegister r5 + // %11 = AddWithCarry %10, #0x8a00, %2 + // SetRegister r4, %11 + // + // The reference to %2 in instruction %11 was the issue, because instruction %8 + // told the register allocator it was a Use but then modified the value. + // Changing the EmitSet*Flag instruction to declare their arguments as UseScratch + // solved this bug. + + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xe35f0cd9, // cmp pc, #55552 + 0xe11c0474, // tst r12, r4, ror r4 + 0xe1a006a7, // mov r0, r7, lsr #13 + 0xe35107fa, // cmp r1, #0x3E80000 + 0xe2a54c8a, // adc r4, r5, #35328 + 0xeafffffe, // b +#0 + }; + + jit.Regs() = { + 0x6973b6bb, 0x267ea626, 0x69debf49, 0x8f976895, 0x4ecd2d0d, 0xcf89b8c7, 0xb6713f85, 0x15e2aa5, + 0xcd14336a, 0xafca0f3e, 0xace2efd9, 0x68fb82cd, 0x775447c0, 0xc9e1f8cd, 0xebe0e626, 0x0}; + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 6; + jit.Run(); + + REQUIRE(jit.Regs()[0] == 0x00000af1); + REQUIRE(jit.Regs()[1] == 0x267ea626); + REQUIRE(jit.Regs()[2] == 0x69debf49); + REQUIRE(jit.Regs()[3] == 0x8f976895); + REQUIRE(jit.Regs()[4] == 0xcf8a42c8); + REQUIRE(jit.Regs()[5] == 0xcf89b8c7); + REQUIRE(jit.Regs()[6] == 0xb6713f85); + REQUIRE(jit.Regs()[7] == 0x015e2aa5); + REQUIRE(jit.Regs()[8] == 0xcd14336a); + REQUIRE(jit.Regs()[9] == 0xafca0f3e); + REQUIRE(jit.Regs()[10] == 0xace2efd9); + REQUIRE(jit.Regs()[11] == 0x68fb82cd); + REQUIRE(jit.Regs()[12] == 0x775447c0); + REQUIRE(jit.Regs()[13] == 0xc9e1f8cd); + REQUIRE(jit.Regs()[14] == 0xebe0e626); + REQUIRE(jit.Regs()[15] == 0x00000014); + REQUIRE(jit.Cpsr() == 0x200001d0); +} + +TEST_CASE("arm: shsax (Edge-case)", "[arm][A32]") { + // This was a randomized test-case that was failing. + // + // The issue here was one of the words to be subtracted was 0x8000. + // When the 2s complement was calculated by (~a + 1), it was 0x8000. + + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xe63dbf59, // shsax r11, sp, r9 + 0xeafffffe, // b +#0 + }; + + jit.Regs() = { + 0x3a3b8b18, 0x96156555, 0xffef039f, 0xafb946f2, 0x2030a69a, 0xafe09b2a, 0x896823c8, 0xabde0ded, + 0x9825d6a6, 0x17498000, 0x999d2c95, 0x8b812a59, 0x209bdb58, 0x2f7fb1d4, 0x0f378107, 0x00000000}; + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.Regs()[0] == 0x3a3b8b18); + REQUIRE(jit.Regs()[1] == 0x96156555); + REQUIRE(jit.Regs()[2] == 0xffef039f); + REQUIRE(jit.Regs()[3] == 0xafb946f2); + REQUIRE(jit.Regs()[4] == 0x2030a69a); + REQUIRE(jit.Regs()[5] == 0xafe09b2a); + REQUIRE(jit.Regs()[6] == 0x896823c8); + REQUIRE(jit.Regs()[7] == 0xabde0ded); + REQUIRE(jit.Regs()[8] == 0x9825d6a6); + REQUIRE(jit.Regs()[9] == 0x17498000); + REQUIRE(jit.Regs()[10] == 0x999d2c95); + REQUIRE(jit.Regs()[11] == 0x57bfe48e); + REQUIRE(jit.Regs()[12] == 0x209bdb58); + REQUIRE(jit.Regs()[13] == 0x2f7fb1d4); + REQUIRE(jit.Regs()[14] == 0x0f378107); + REQUIRE(jit.Regs()[15] == 0x00000004); + REQUIRE(jit.Cpsr() == 0x000001d0); +} + +TEST_CASE("arm: uasx (Edge-case)", "[arm][A32]") { + // UASX's Rm<31:16> == 0x0000. + // An implementation that depends on addition overflow to detect + // if diff >= 0 will fail this testcase. + + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xe6549f35, // uasx r9, r4, r5 + 0xeafffffe, // b +#0 + }; + + jit.Regs()[4] = 0x8ed38f4c; + jit.Regs()[5] = 0x0000261d; + jit.Regs()[15] = 0x00000000; + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.Regs()[4] == 0x8ed38f4c); + REQUIRE(jit.Regs()[5] == 0x0000261d); + REQUIRE(jit.Regs()[9] == 0xb4f08f4c); + REQUIRE(jit.Regs()[15] == 0x00000004); + REQUIRE(jit.Cpsr() == 0x000301d0); +} + +TEST_CASE("arm: smuad (Edge-case)", "[arm][A32]") { + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xE700F211, // smuad r0, r1, r2 + 0xeafffffe, // b +#0 + }; + + jit.Regs() = { + 0, // Rd + 0x80008000, // Rn + 0x80008000, // Rm + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + }; + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.Regs()[0] == 0x80000000); + REQUIRE(jit.Regs()[1] == 0x80008000); + REQUIRE(jit.Regs()[2] == 0x80008000); + REQUIRE(jit.Cpsr() == 0x080001d0); +} + +TEST_CASE("arm: Test InvalidateCacheRange", "[arm][A32]") { + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xe3a00005, // mov r0, #5 + 0xe3a0100D, // mov r1, #13 + 0xe0812000, // add r2, r1, r0 + 0xeafffffe, // b +#0 (infinite loop) + }; + + jit.Regs() = {}; + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.Regs()[0] == 5); + REQUIRE(jit.Regs()[1] == 13); + REQUIRE(jit.Regs()[2] == 18); + REQUIRE(jit.Regs()[15] == 0x0000000c); + REQUIRE(jit.Cpsr() == 0x000001d0); + + // Change the code + test_env.code_mem[1] = 0xe3a01007; // mov r1, #7 + jit.InvalidateCacheRange(/*start_memory_location = */ 4, /* length_in_bytes = */ 4); + + // Reset position of PC + jit.Regs()[15] = 0; + + test_env.ticks_left = 4; + jit.Run(); + jit.Run(); + + REQUIRE(jit.Regs()[0] == 5); + REQUIRE(jit.Regs()[1] == 7); + REQUIRE(jit.Regs()[2] == 12); + REQUIRE(jit.Regs()[15] == 0x0000000c); + REQUIRE(jit.Cpsr() == 0x000001d0); +} + +TEST_CASE("arm: Step blx", "[arm]") { + ArmTestEnv test_env; + A32::UserConfig config = GetUserConfig(&test_env); + config.optimizations |= OptimizationFlag::FastDispatch; + Dynarmic::A32::Jit jit{config}; + test_env.code_mem = { + 0xe12fff30, // blx r0 + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xeafffffe, // b +#0 (infinite loop) + }; + + jit.Regs()[0] = 8; + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 10; + jit.Step(); + + REQUIRE(jit.Regs()[0] == 8); + REQUIRE(jit.Regs()[14] == 4); + REQUIRE(jit.Regs()[15] == 8); + REQUIRE(jit.Cpsr() == 0x000001d0); +} + +TEST_CASE("arm: Step bx", "[arm]") { + ArmTestEnv test_env; + A32::UserConfig config = GetUserConfig(&test_env); + config.optimizations |= OptimizationFlag::FastDispatch; + Dynarmic::A32::Jit jit{config}; + test_env.code_mem = { + 0xe12fff10, // bx r0 + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xeafffffe, // b +#0 (infinite loop) + }; + + jit.Regs()[0] = 8; + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 10; + jit.Step(); + + REQUIRE(jit.Regs()[0] == 8); + REQUIRE(jit.Regs()[15] == 8); + REQUIRE(jit.Cpsr() == 0x000001d0); +} + +TEST_CASE("arm: Test stepping", "[arm]") { + ArmTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + + 0xeafffffe, // b +#0 (infinite loop) + }; + + jit.Regs()[0] = 8; + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x000001d0); // User-mode + + for (size_t i = 0; i < 5; ++i) { + test_env.ticks_left = 10; + jit.Step(); + + REQUIRE(jit.Regs()[15] == (i + 1) * 4); + REQUIRE(jit.Cpsr() == 0x000001d0); + } + + test_env.ticks_left = 20; + jit.Run(); + + REQUIRE(jit.Regs()[15] == 80); + REQUIRE(jit.Cpsr() == 0x000001d0); +} + +TEST_CASE("arm: Test stepping 2", "[arm]") { + ArmTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xe12fff10, // bx r0 + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + + 0xeafffffe, // b +#0 (infinite loop) + }; + + jit.Regs()[0] = 4; + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x000001d0); // User-mode + + for (size_t i = 0; i < 5; ++i) { + test_env.ticks_left = 10; + jit.Step(); + + REQUIRE(jit.Regs()[15] == (i + 1) * 4); + REQUIRE(jit.Cpsr() == 0x000001d0); + } + + test_env.ticks_left = 20; + jit.Run(); + + REQUIRE(jit.Regs()[15] == 80); + REQUIRE(jit.Cpsr() == 0x000001d0); +} + +TEST_CASE("arm: Test stepping 3", "[arm]") { + ArmTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xe12fff10, // bx r0 + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + 0xe320f000, // nop + + 0xeafffffe, // b +#0 (infinite loop) + }; + + jit.Regs()[0] = 4; + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 10; + jit.Step(); + + REQUIRE(jit.Regs()[15] == 4); + REQUIRE(jit.Cpsr() == 0x000001d0); + + test_env.ticks_left = 20; + jit.Run(); + + REQUIRE(jit.Regs()[15] == 20); + REQUIRE(jit.Cpsr() == 0x000001d0); +} + +TEST_CASE("arm: PackedAbsDiffSumS8", "[arm][A32]") { + // This was a randomized test-case that was failing. + // In circumstances there were cases when the upper 32 bits of an argument to psadbw were not zero. + + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0x87414354, // smlsldhi r4, r1, r4, r3 + 0xe7886412, // usad8a r8, r2, r4, r6 + 0xeafffffe, // b +#0 + }; + + jit.Regs() = { + 0xea85297c, + 0x417ad918, + 0x64f8b70b, + 0xcca0373e, + 0xbc722361, + 0xc528c69e, + 0xca926de8, + 0xd665d210, + 0xb5650555, + 0x4a24b25b, + 0xaed44144, + 0xe87230b2, + 0x98e391de, + 0x126efc0c, + 0xe591fd11, + 0x00000000, + }; + jit.SetCpsr(0xb0000010); + + test_env.ticks_left = 3; + jit.Run(); + + REQUIRE(jit.Regs()[0] == 0xea85297c); + REQUIRE(jit.Regs()[1] == 0x417ad918); + REQUIRE(jit.Regs()[2] == 0x64f8b70b); + REQUIRE(jit.Regs()[3] == 0xcca0373e); + REQUIRE(jit.Regs()[4] == 0xb685ec9f); + REQUIRE(jit.Regs()[5] == 0xc528c69e); + REQUIRE(jit.Regs()[6] == 0xca926de8); + REQUIRE(jit.Regs()[7] == 0xd665d210); + REQUIRE(jit.Regs()[8] == 0xca926f76); + REQUIRE(jit.Regs()[9] == 0x4a24b25b); + REQUIRE(jit.Regs()[10] == 0xaed44144); + REQUIRE(jit.Regs()[11] == 0xe87230b2); + REQUIRE(jit.Regs()[12] == 0x98e391de); + REQUIRE(jit.Regs()[13] == 0x126efc0c); + REQUIRE(jit.Regs()[14] == 0xe591fd11); + REQUIRE(jit.Regs()[15] == 0x00000008); + REQUIRE(jit.Cpsr() == 0xb0000010); +} + +TEST_CASE("arm: vclt.f32 with zero", "[arm][A32]") { + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xf3b93628, // vclt.f32 d3, d24, #0 + 0xeafffffe, // b +#0 + }; + + jit.ExtRegs()[48] = 0x3a87d9f1; + jit.ExtRegs()[49] = 0x80796dc0; + + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.ExtRegs()[6] == 0x00000000); + REQUIRE(jit.ExtRegs()[7] == 0x00000000); +} + +TEST_CASE("arm: vcvt.s16.f64", "[arm][A32]") { + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xeebe8b45, // vcvt.s16.f64 d8, d8, #6 + 0xeafffffe, // b +#0 + }; + + jit.ExtRegs()[16] = 0x9a7110b0; + jit.ExtRegs()[17] = 0xcd78f4e7; + + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.ExtRegs()[16] == 0xffff8000); + REQUIRE(jit.ExtRegs()[17] == 0xffffffff); +} + +TEST_CASE("arm: Memory access (fastmem)", "[arm][A32]") { + constexpr size_t address_width = 12; + constexpr size_t memory_size = 1ull << address_width; // 4K + constexpr size_t page_size = 4 * 1024; + constexpr size_t buffer_size = 2 * page_size; + char buffer[buffer_size]; + + void* buffer_ptr = reinterpret_cast<void*>(buffer); + size_t buffer_size_nconst = buffer_size; + char* backing_memory = reinterpret_cast<char*>(std::align(page_size, memory_size, buffer_ptr, buffer_size_nconst)); + + A32FastmemTestEnv env{backing_memory}; + Dynarmic::A32::UserConfig config{&env}; + config.fastmem_pointer = backing_memory; + config.recompile_on_fastmem_failure = false; + config.processor_id = 0; + + Dynarmic::A32::Jit jit{config}; + memset(backing_memory, 0, memory_size); + memcpy(backing_memory + 0x100, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 57); + + env.MemoryWrite32(0, 0xE5904000); // LDR R4, [R0] + env.MemoryWrite32(4, 0xE5814000); // STR R4, [R1] + env.MemoryWrite32(8, 0xEAFFFFFE); // B . + jit.Regs()[0] = 0x100; + jit.Regs()[1] = 0x1F0; + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x000001d0); // User-mode + env.ticks_left = 3; + + jit.Run(); + REQUIRE(strncmp(backing_memory + 0x100, backing_memory + 0x1F0, 4) == 0); +} + +TEST_CASE("arm: vmsr, vcmp, vmrs", "[arm][A32]") { + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xeee10a10, // vmsr fpscr, r0 + 0xeeb48a4a, // vcmp.f32 s16, s20 + 0xeef1fa10, // vmrs apsr_nzcv, fpscr + 0xe12fff1e, // bx lr + }; + + jit.ExtRegs()[16] = 0xFF7FFFFF; + jit.ExtRegs()[20] = 0xFF7FFFFF; + + jit.Regs()[0] = 0x60000000; + + jit.SetFpscr(0x3ee22ac0); + jit.SetCpsr(0x60000000); // User-mode + + test_env.ticks_left = 4; + jit.Run(); +} + +TEST_CASE("arm: sdiv maximally", "[arm][A32]") { + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xe712f011, // sdiv r2, r1, r0 + 0xeafffffe, // b +#0 + }; + + jit.Regs()[1] = 0x80000000; + jit.Regs()[0] = 0xffffffff; + + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.Regs()[2] == 0x80000000); +} + +TEST_CASE("arm: tbl", "[arm][A32]") { + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + + test_env.code_mem.emplace_back(0xf3f408a0); // vtbl.8 d16, {d20 }, d16 + test_env.code_mem.emplace_back(0xf3f419a1); // vtbl.8 d17, {d20, d21 }, d17 + test_env.code_mem.emplace_back(0xf3f42aa2); // vtbl.8 d18, {d20, d21, d22 }, d18 + test_env.code_mem.emplace_back(0xf3f43ba3); // vtbl.8 d19, {d20, d21, d22, d23}, d19 + test_env.code_mem.emplace_back(0xeafffffe); // b +#0 + + // Indices + jit.ExtRegs()[16 * 2 + 0] = 0x05'02'01'00; + jit.ExtRegs()[16 * 2 + 1] = 0x20'1F'10'0F; + + jit.ExtRegs()[17 * 2 + 0] = 0x05'02'01'00; + jit.ExtRegs()[17 * 2 + 1] = 0x20'1F'10'0F; + + jit.ExtRegs()[18 * 2 + 0] = 0x05'02'01'00; + jit.ExtRegs()[18 * 2 + 1] = 0x20'1F'10'0F; + + jit.ExtRegs()[19 * 2 + 0] = 0x05'02'01'00; + jit.ExtRegs()[19 * 2 + 1] = 0x20'1F'10'0F; + + // Table + jit.ExtRegs()[20 * 2 + 0] = 0x03'02'01'00; + jit.ExtRegs()[20 * 2 + 1] = 0x07'06'05'04; + jit.ExtRegs()[21 * 2 + 0] = 0x0B'0A'09'08; + jit.ExtRegs()[21 * 2 + 1] = 0x0F'0E'0D'0C; + jit.ExtRegs()[22 * 2 + 0] = 0x13'12'11'10; + jit.ExtRegs()[22 * 2 + 1] = 0x17'16'15'14; + jit.ExtRegs()[23 * 2 + 0] = 0x1B'1A'19'18; + jit.ExtRegs()[23 * 2 + 1] = 0x1F'1E'1D'1C; + + test_env.ticks_left = 5; + jit.Run(); + + REQUIRE(jit.ExtRegs()[16 * 2 + 0] == 0x05'02'01'00); + REQUIRE(jit.ExtRegs()[16 * 2 + 1] == 0x00'00'00'00); + + REQUIRE(jit.ExtRegs()[17 * 2 + 0] == 0x05'02'01'00); + REQUIRE(jit.ExtRegs()[17 * 2 + 1] == 0x00'00'00'0F); + + REQUIRE(jit.ExtRegs()[18 * 2 + 0] == 0x05'02'01'00); + REQUIRE(jit.ExtRegs()[18 * 2 + 1] == 0x00'00'10'0F); + + REQUIRE(jit.ExtRegs()[19 * 2 + 0] == 0x05'02'01'00); + REQUIRE(jit.ExtRegs()[19 * 2 + 1] == 0x00'1F'10'0F); +} + +TEST_CASE("arm: tbx", "[arm][A32]") { + ArmTestEnv test_env; + A32::Jit jit{GetUserConfig(&test_env)}; + + test_env.code_mem.emplace_back(0xf3f408e0); // vtbx.8 d16, {d20 }, d16 + test_env.code_mem.emplace_back(0xf3f419e1); // vtbx.8 d17, {d20, d21 }, d17 + test_env.code_mem.emplace_back(0xf3f42ae2); // vtbx.8 d18, {d20, d21, d22 }, d18 + test_env.code_mem.emplace_back(0xf3f43be3); // vtbx.8 d19, {d20, d21, d22, d23}, d19 + test_env.code_mem.emplace_back(0xeafffffe); // b +#0 + + // Indices + jit.ExtRegs()[16 * 2 + 0] = 0x05'02'01'00; + jit.ExtRegs()[16 * 2 + 1] = 0x20'1F'10'0F; + + jit.ExtRegs()[17 * 2 + 0] = 0x05'02'01'00; + jit.ExtRegs()[17 * 2 + 1] = 0x20'1F'10'0F; + + jit.ExtRegs()[18 * 2 + 0] = 0x05'02'01'00; + jit.ExtRegs()[18 * 2 + 1] = 0x20'1F'10'0F; + + jit.ExtRegs()[19 * 2 + 0] = 0x05'02'01'00; + jit.ExtRegs()[19 * 2 + 1] = 0x20'1F'10'0F; + + // Table + jit.ExtRegs()[20 * 2 + 0] = 0x03'02'01'00; + jit.ExtRegs()[20 * 2 + 1] = 0x07'06'05'04; + + jit.ExtRegs()[21 * 2 + 0] = 0x0B'0A'09'08; + jit.ExtRegs()[21 * 2 + 1] = 0x0F'0E'0D'0C; + + jit.ExtRegs()[22 * 2 + 0] = 0x13'12'11'10; + jit.ExtRegs()[22 * 2 + 1] = 0x17'16'15'14; + + jit.ExtRegs()[23 * 2 + 0] = 0x1B'1A'19'18; + jit.ExtRegs()[23 * 2 + 1] = 0x1F'1E'1D'1C; + + test_env.ticks_left = 5; + jit.Run(); + + REQUIRE(jit.ExtRegs()[16 * 2 + 0] == 0x05'02'01'00); + REQUIRE(jit.ExtRegs()[16 * 2 + 1] == 0x20'1F'10'0F); + + REQUIRE(jit.ExtRegs()[17 * 2 + 0] == 0x05'02'01'00); + REQUIRE(jit.ExtRegs()[17 * 2 + 1] == 0x20'1F'10'0F); + + REQUIRE(jit.ExtRegs()[18 * 2 + 0] == 0x05'02'01'00); + REQUIRE(jit.ExtRegs()[18 * 2 + 1] == 0x20'1F'10'0F); + + REQUIRE(jit.ExtRegs()[19 * 2 + 0] == 0x05'02'01'00); + REQUIRE(jit.ExtRegs()[19 * 2 + 1] == 0x20'1F'10'0F); +} diff --git a/externals/dynarmic/tests/A32/test_coprocessor.cpp b/externals/dynarmic/tests/A32/test_coprocessor.cpp new file mode 100644 index 0000000000..24d54efe4f --- /dev/null +++ b/externals/dynarmic/tests/A32/test_coprocessor.cpp @@ -0,0 +1,228 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2022 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <memory> + +#include <catch2/catch_test_macros.hpp> + +#include "./testenv.h" +#include "dynarmic/frontend/A32/a32_location_descriptor.h" +#include "dynarmic/interface/A32/a32.h" +#include "dynarmic/interface/A32/coprocessor.h" + +using namespace Dynarmic; + +struct CP15State { + u32 cp15_thread_uprw = 0; + u32 cp15_thread_uro = 0; + u32 cp15_flush_prefetch_buffer = 0; ///< dummy value + u32 cp15_data_sync_barrier = 0; ///< dummy value + u32 cp15_data_memory_barrier = 0; ///< dummy value +}; + +class TestCP15 final : public Dynarmic::A32::Coprocessor { +public: + using CoprocReg = Dynarmic::A32::CoprocReg; + + explicit TestCP15(CP15State&); + ~TestCP15() override; + + std::optional<Callback> CompileInternalOperation(bool two, unsigned opc1, CoprocReg CRd, CoprocReg CRn, CoprocReg CRm, unsigned opc2) override; + CallbackOrAccessOneWord CompileSendOneWord(bool two, unsigned opc1, CoprocReg CRn, CoprocReg CRm, unsigned opc2) override; + CallbackOrAccessTwoWords CompileSendTwoWords(bool two, unsigned opc, CoprocReg CRm) override; + CallbackOrAccessOneWord CompileGetOneWord(bool two, unsigned opc1, CoprocReg CRn, CoprocReg CRm, unsigned opc2) override; + CallbackOrAccessTwoWords CompileGetTwoWords(bool two, unsigned opc, CoprocReg CRm) override; + std::optional<Callback> CompileLoadWords(bool two, bool long_transfer, CoprocReg CRd, std::optional<u8> option) override; + std::optional<Callback> CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd, std::optional<u8> option) override; + +private: + CP15State& state; +}; + +using Callback = Dynarmic::A32::Coprocessor::Callback; +using CallbackOrAccessOneWord = Dynarmic::A32::Coprocessor::CallbackOrAccessOneWord; +using CallbackOrAccessTwoWords = Dynarmic::A32::Coprocessor::CallbackOrAccessTwoWords; + +TestCP15::TestCP15(CP15State& state) + : state(state) {} + +TestCP15::~TestCP15() = default; + +std::optional<Callback> TestCP15::CompileInternalOperation([[maybe_unused]] bool two, [[maybe_unused]] unsigned opc1, [[maybe_unused]] CoprocReg CRd, [[maybe_unused]] CoprocReg CRn, [[maybe_unused]] CoprocReg CRm, [[maybe_unused]] unsigned opc2) { + return std::nullopt; +} + +CallbackOrAccessOneWord TestCP15::CompileSendOneWord(bool two, unsigned opc1, CoprocReg CRn, CoprocReg CRm, unsigned opc2) { + if (!two && CRn == CoprocReg::C7 && opc1 == 0 && CRm == CoprocReg::C5 && opc2 == 4) { + return Callback{ + [](void* user_arg, std::uint32_t, std::uint32_t) -> std::uint64_t { + CP15State& state = *reinterpret_cast<CP15State*>(user_arg); + state.cp15_flush_prefetch_buffer = 1; + return 0; + }, + reinterpret_cast<void*>(&state), + }; + } + + if (!two && CRn == CoprocReg::C7 && opc1 == 0 && CRm == CoprocReg::C10) { + switch (opc2) { + case 4: + return Callback{ + [](void* user_arg, std::uint32_t, std::uint32_t) -> std::uint64_t { + CP15State& state = *reinterpret_cast<CP15State*>(user_arg); + state.cp15_data_sync_barrier = 1; + return 0; + }, + reinterpret_cast<void*>(&state), + }; + case 5: + return Callback{ + [](void* user_arg, std::uint32_t, std::uint32_t) -> std::uint64_t { + CP15State& state = *reinterpret_cast<CP15State*>(user_arg); + state.cp15_data_memory_barrier = 1; + return 0; + }, + reinterpret_cast<void*>(&state), + }; + default: + return std::monostate{}; + } + } + + if (!two && CRn == CoprocReg::C13 && opc1 == 0 && CRm == CoprocReg::C0 && opc2 == 2) { + return &state.cp15_thread_uprw; + } + + return std::monostate{}; +} + +CallbackOrAccessTwoWords TestCP15::CompileSendTwoWords([[maybe_unused]] bool two, [[maybe_unused]] unsigned opc, [[maybe_unused]] CoprocReg CRm) { + return std::monostate{}; +} + +CallbackOrAccessOneWord TestCP15::CompileGetOneWord(bool two, unsigned opc1, CoprocReg CRn, CoprocReg CRm, unsigned opc2) { + // TODO(merry): Privileged CP15 registers + + if (!two && CRn == CoprocReg::C13 && opc1 == 0 && CRm == CoprocReg::C0) { + switch (opc2) { + case 2: + return &state.cp15_thread_uprw; + case 3: + return &state.cp15_thread_uro; + default: + return std::monostate{}; + } + } + + return std::monostate{}; +} + +CallbackOrAccessTwoWords TestCP15::CompileGetTwoWords([[maybe_unused]] bool two, [[maybe_unused]] unsigned opc, [[maybe_unused]] CoprocReg CRm) { + return std::monostate{}; +} + +std::optional<Callback> TestCP15::CompileLoadWords([[maybe_unused]] bool two, [[maybe_unused]] bool long_transfer, [[maybe_unused]] CoprocReg CRd, [[maybe_unused]] std::optional<u8> option) { + return std::nullopt; +} + +std::optional<Callback> TestCP15::CompileStoreWords([[maybe_unused]] bool two, [[maybe_unused]] bool long_transfer, [[maybe_unused]] CoprocReg CRd, [[maybe_unused]] std::optional<u8> option) { + return std::nullopt; +} + +static A32::UserConfig GetUserConfig(ArmTestEnv* testenv, CP15State& cp15_state) { + A32::UserConfig user_config; + user_config.optimizations &= ~OptimizationFlag::FastDispatch; + user_config.callbacks = testenv; + user_config.coprocessors[15] = std::make_unique<TestCP15>(cp15_state); + return user_config; +} + +TEST_CASE("arm: Test coprocessor (Read TPIDRURO)", "[arm][A32]") { + ArmTestEnv test_env; + CP15State cp15_state; + A32::Jit jit{GetUserConfig(&test_env, cp15_state)}; + + cp15_state.cp15_thread_uro = 0xf00d; + cp15_state.cp15_thread_uprw = 0xcafe; + jit.Regs()[0] = 0xaaaa; + + test_env.code_mem = { + 0xee1d1f70, // mrc p15, 0, r1, c13, c0, 3 (Read TPIDRURO into R1) + 0xeafffffe, // b +#0 + }; + + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.Regs()[1] == 0xf00d); +} + +TEST_CASE("arm: Test coprocessor (Read TPIDRURW)", "[arm][A32]") { + ArmTestEnv test_env; + CP15State cp15_state; + A32::Jit jit{GetUserConfig(&test_env, cp15_state)}; + + cp15_state.cp15_thread_uro = 0xf00d; + cp15_state.cp15_thread_uprw = 0xcafe; + jit.Regs()[0] = 0xaaaa; + + test_env.code_mem = { + 0xee1d1f50, // mrc p15, 0, r1, c13, c0, 2 (Read TPIDRURW into R1) + 0xeafffffe, // b +#0 + }; + + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.Regs()[1] == 0xcafe); +} + +TEST_CASE("arm: Test coprocessor (Write TPIDRURW)", "[arm][A32]") { + ArmTestEnv test_env; + CP15State cp15_state; + A32::Jit jit{GetUserConfig(&test_env, cp15_state)}; + + cp15_state.cp15_thread_uro = 0xf00d; + cp15_state.cp15_thread_uprw = 0xcafe; + jit.Regs()[0] = 0xaaaa; + + test_env.code_mem = { + 0xee0d0f50, // mcr p15, 0, r0, c13, c0, 2 (Write R0 into TPIDRURW) + 0xeafffffe, // b +#0 + }; + + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 2; + jit.Run(); + + REQUIRE(cp15_state.cp15_thread_uprw == 0xaaaa); +} + +TEST_CASE("arm: Test coprocessor (DMB)", "[arm][A32]") { + ArmTestEnv test_env; + CP15State cp15_state; + A32::Jit jit{GetUserConfig(&test_env, cp15_state)}; + + cp15_state.cp15_thread_uro = 0xf00d; + cp15_state.cp15_thread_uprw = 0xcafe; + jit.Regs()[0] = 0xaaaa; + + test_env.code_mem = { + 0xee070fba, // mcr p15, 0, r0, c7, c10, 5 (Data Memory Barrier) + 0xeafffffe, // b +#0 + }; + + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 2; + jit.Run(); + + REQUIRE(cp15_state.cp15_data_memory_barrier == 1); +} diff --git a/externals/dynarmic/tests/A32/test_svc.cpp b/externals/dynarmic/tests/A32/test_svc.cpp new file mode 100644 index 0000000000..bec02b76f6 --- /dev/null +++ b/externals/dynarmic/tests/A32/test_svc.cpp @@ -0,0 +1,39 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2022 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <optional> + +#include <catch2/catch_test_macros.hpp> + +#include "./testenv.h" + +using namespace Dynarmic; + +class ArmSvcTestEnv : public ArmTestEnv { +public: + std::optional<u32> svc_called = std::nullopt; + void CallSVC(u32 swi) override { + svc_called = swi; + } +}; + +TEST_CASE("arm: svc", "[arm][A32]") { + ArmSvcTestEnv test_env; + A32::Jit jit{A32::UserConfig{&test_env}}; + test_env.code_mem = { + 0xef0001ee, // svc #0x1ee + 0xe30a0071, // mov r0, #41073 + 0xeafffffe, // b +#0 + }; + + jit.SetCpsr(0x000001d0); // User-mode + + test_env.ticks_left = 3; + jit.Run(); + + REQUIRE(test_env.svc_called == 0x1ee); + REQUIRE(jit.Regs()[15] == 0x00000008); + REQUIRE(jit.Regs()[0] == 41073); +} diff --git a/externals/dynarmic/tests/A32/test_thumb_instructions.cpp b/externals/dynarmic/tests/A32/test_thumb_instructions.cpp new file mode 100644 index 0000000000..dda0fc46b5 --- /dev/null +++ b/externals/dynarmic/tests/A32/test_thumb_instructions.cpp @@ -0,0 +1,254 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2016 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <catch2/catch_test_macros.hpp> +#include <mcl/stdint.hpp> + +#include "./testenv.h" +#include "dynarmic/interface/A32/a32.h" + +static Dynarmic::A32::UserConfig GetUserConfig(ThumbTestEnv* testenv) { + Dynarmic::A32::UserConfig user_config; + user_config.callbacks = testenv; + return user_config; +} + +TEST_CASE("thumb: lsls r0, r1, #2", "[thumb]") { + ThumbTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0x0088, // lsls r0, r1, #2 + 0xE7FE, // b +#0 + }; + + jit.Regs()[0] = 1; + jit.Regs()[1] = 2; + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x00000030); // Thumb, User-mode + + test_env.ticks_left = 1; + jit.Run(); + + REQUIRE(jit.Regs()[0] == 8); + REQUIRE(jit.Regs()[1] == 2); + REQUIRE(jit.Regs()[15] == 2); + REQUIRE(jit.Cpsr() == 0x00000030); +} + +TEST_CASE("thumb: lsls r0, r1, #31", "[thumb]") { + ThumbTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0x07C8, // lsls r0, r1, #31 + 0xE7FE, // b +#0 + }; + + jit.Regs()[0] = 1; + jit.Regs()[1] = 0xFFFFFFFF; + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x00000030); // Thumb, User-mode + + test_env.ticks_left = 1; + jit.Run(); + + REQUIRE(jit.Regs()[0] == 0x80000000); + REQUIRE(jit.Regs()[1] == 0xffffffff); + REQUIRE(jit.Regs()[15] == 2); + REQUIRE(jit.Cpsr() == 0xA0000030); // N, C flags, Thumb, User-mode +} + +TEST_CASE("thumb: revsh r4, r3", "[thumb]") { + ThumbTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xBADC, // revsh r4, r3 + 0xE7FE, // b +#0 + }; + + jit.Regs()[3] = 0x12345678; + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x00000030); // Thumb, User-mode + + test_env.ticks_left = 1; + jit.Run(); + + REQUIRE(jit.Regs()[3] == 0x12345678); + REQUIRE(jit.Regs()[4] == 0x00007856); + REQUIRE(jit.Regs()[15] == 2); + REQUIRE(jit.Cpsr() == 0x00000030); // Thumb, User-mode +} + +TEST_CASE("thumb: ldr r3, [r3, #28]", "[thumb]") { + ThumbTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0x69DB, // ldr r3, [r3, #28] + 0xE7FE, // b +#0 + }; + + jit.Regs()[3] = 0x12345678; + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x00000030); // Thumb, User-mode + + test_env.ticks_left = 1; + jit.Run(); + + REQUIRE(jit.Regs()[3] == 0x97969594); // Memory location 0x12345694 + REQUIRE(jit.Regs()[15] == 2); + REQUIRE(jit.Cpsr() == 0x00000030); // Thumb, User-mode +} + +TEST_CASE("thumb: blx +#67712", "[thumb]") { + ThumbTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xF010, 0xEC3E, // blx +#67712 + 0xE7FE // b +#0 + }; + + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x00000030); // Thumb, User-mode + + test_env.ticks_left = 1; + jit.Run(); + + REQUIRE(jit.Regs()[14] == (0x4 | 1)); + REQUIRE(jit.Regs()[15] == 0x10880); + REQUIRE(jit.Cpsr() == 0x00000010); // User-mode +} + +TEST_CASE("thumb: bl +#234584", "[thumb]") { + ThumbTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xF039, 0xFA2A, // bl +#234584 + 0xE7FE // b +#0 + }; + + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x00000030); // Thumb, User-mode + + test_env.ticks_left = 1; + jit.Run(); + + REQUIRE(jit.Regs()[14] == (0x4 | 1)); + REQUIRE(jit.Regs()[15] == 0x39458); + REQUIRE(jit.Cpsr() == 0x00000030); // Thumb, User-mode +} + +TEST_CASE("thumb: bl -#42", "[thumb]") { + ThumbTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0xF7FF, 0xFFE9, // bl -#42 + 0xE7FE // b +#0 + }; + + jit.Regs()[15] = 0; // PC = 0 + jit.SetCpsr(0x00000030); // Thumb, User-mode + + test_env.ticks_left = 1; + jit.Run(); + + REQUIRE(jit.Regs()[14] == (0x4 | 1)); + REQUIRE(jit.Regs()[15] == 0xFFFFFFD6); + REQUIRE(jit.Cpsr() == 0x00000030); // Thumb, User-mode +} + +TEST_CASE("thumb: Opt Failure: Get/Set Elimination for Flags", "[thumb]") { + // This was a randomized test-case that was failing. + // + // Incorrect IR: + // Block: location={0000000100000000} + // cycles=6, entry_cond=al + // [0000556569455160] %0 = GetRegister r1 (uses: 1) + // [00005565694551c8] %1 = GetRegister r6 (uses: 1) + // [0000556569455230] %2 = Mul32 %1, %0 (uses: 1) + // [0000556569455298] SetRegister r6, %2 (uses: 0) + // [0000556569455300] Void (uses: 0) + // [00005565694553d0] Void (uses: 0) + // [0000556569455438] Void (uses: 0) + // [00005565694554a0] Void (uses: 0) + // [0000556569455508] Void (uses: 0) + // [00005565694555d8] %9 = GetCFlag (uses: 1) + // [0000556569455640] %10 = GetRegister r3 (uses: 2) + // [00005565694556a8] %11 = Identity %10 (uses: 1) + // [0000556569455710] %12 = Add32 %11, %10, %9 (uses: 2) + // [0000556569455778] SetRegister r3, %12 (uses: 0) + // [00005565694557e0] %14 = GetNZCVFromOp %12 (uses: 1) + // [0000556569455848] SetCpsrNZCV %14 (uses: 0) + // [00005565694558b0] %16 = GetRegister sp (uses: 1) + // [0000556569455918] %17 = Add32 %16, #0x2c4, #0 (uses: 1) + // [0000556569455980] %18 = GetRegister r4 (uses: 1) + // [00005565694559e8] WriteMemory32 #0x100000006, %17, %18, <unknown immediate type> (uses: 0) + // [0000556569455a50] %20 = GetRegister r2 (uses: 1) + // [0000556569455ab8] %21 = GetRegister r5 (uses: 1) + // [0000556569455b20] %22 = Add32 %21, %20, #0 (uses: 1) + // [0000556569455b88] SetRegister r5, %22 (uses: 0) + // terminal = LinkBlock{{000000010000000a}} + + ThumbTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0x434e, // muls r6, r1, r6 + 0x4557, // cmp r7, r10 + 0x415b, // adcs r3, r3 + 0x94b1, // str r4, [sp, #708] + 0x4415, // add r5, r2 + 0xe7fe // b +#0 + }; + + jit.Regs() = {0x2154abb5, 0xdbaa6333, 0xf8a7bc0e, 0x989f6096, 0x19cd7783, 0xe1cf5b7f, 0x9bb1aa6c, 0x6b700f5c, + 0xc04f6cb2, 0xc8df07f0, 0x217d83de, 0xe77fdffa, 0x98bcceaf, 0xbfcab4f7, 0xdb9d5405, 0x00000000}; + jit.SetCpsr(0x000001f0); // Thumb, User-mode + + test_env.ticks_left = 7; + jit.Run(); + + REQUIRE(jit.Regs()[0] == 0x2154abb5); + REQUIRE(jit.Regs()[1] == 0xdbaa6333); + REQUIRE(jit.Regs()[2] == 0xf8a7bc0e); + REQUIRE(jit.Regs()[3] == 0x313ec12d); + REQUIRE(jit.Regs()[4] == 0x19cd7783); + REQUIRE(jit.Regs()[5] == 0xda77178d); + REQUIRE(jit.Regs()[6] == 0x4904b784); + REQUIRE(jit.Regs()[7] == 0x6b700f5c); + REQUIRE(jit.Regs()[8] == 0xc04f6cb2); + REQUIRE(jit.Regs()[9] == 0xc8df07f0); + REQUIRE(jit.Regs()[10] == 0x217d83de); + REQUIRE(jit.Regs()[11] == 0xe77fdffa); + REQUIRE(jit.Regs()[12] == 0x98bcceaf); + REQUIRE(jit.Regs()[13] == 0xbfcab4f7); + REQUIRE(jit.Regs()[14] == 0xdb9d5405); + REQUIRE(jit.Regs()[15] == 0x0000000a); + REQUIRE(jit.Cpsr() == 0x300001f0); +} + +TEST_CASE("thumb: Opt Failure: Get/Set Elimination for Flags 2", "[thumb]") { + // This was a randomized test-case that was failing. + + ThumbTestEnv test_env; + Dynarmic::A32::Jit jit{GetUserConfig(&test_env)}; + test_env.code_mem = { + 0x442a, // add r2, r5 + 0x065d, // lsls r5, r3, #25 + 0xbc64, // pop {r2, r5, r6} + 0x2666, // movs r6, #102 + 0x7471, // strb r1, [r6, #17] + 0xe7fe // b +#0 + }; + + jit.Regs() = {0x954d53b0, 0x4caaad40, 0xa42325b8, 0x0da0cdb6, 0x0f43507e, 0x31d68ae1, 0x9c471808, 0x892a6888, + 0x3b9ffb23, 0x0a92ef93, 0x38dee619, 0xc0e95e81, 0x6a448690, 0xc2d4d6ad, 0xe93600b9, 0x00000000}; + jit.SetCpsr(0x000001f0); // Thumb, User-mode + + test_env.ticks_left = 7; + jit.Run(); + + const std::array<u32, 16> expected = {0x954d53b0, 0x4caaad40, 0xb0afaead, 0x0da0cdb6, 0x0f43507e, 0xb4b3b2b1, 0x00000066, 0x892a6888, + 0x3b9ffb23, 0x0a92ef93, 0x38dee619, 0xc0e95e81, 0x6a448690, 0xc2d4d6b9, 0xe93600b9, 0x0000000a}; + REQUIRE(jit.Regs() == expected); + REQUIRE(jit.Cpsr() == 0x200001f0); +} diff --git a/externals/dynarmic/tests/A32/testenv.h b/externals/dynarmic/tests/A32/testenv.h new file mode 100644 index 0000000000..4345663b34 --- /dev/null +++ b/externals/dynarmic/tests/A32/testenv.h @@ -0,0 +1,201 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#pragma once + +#include <array> +#include <cstring> +#include <map> +#include <string> +#include <vector> + +#include <mcl/assert.hpp> +#include <mcl/stdint.hpp> + +#include "dynarmic/interface/A32/a32.h" + +template<typename InstructionType_, u32 infinite_loop_u32> +class A32TestEnv : public Dynarmic::A32::UserCallbacks { +public: + using InstructionType = InstructionType_; + using RegisterArray = std::array<u32, 16>; + using ExtRegsArray = std::array<u32, 64>; + +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable : 4309) // C4309: 'static_cast': truncation of constant value +#endif + static constexpr InstructionType infinite_loop = static_cast<InstructionType>(infinite_loop_u32); +#ifdef _MSC_VER +# pragma warning(pop) +#endif + + u64 ticks_left = 0; + bool code_mem_modified_by_guest = false; + std::vector<InstructionType> code_mem; + std::map<u32, u8> modified_memory; + std::vector<std::string> interrupts; + + void PadCodeMem() { + do { + code_mem.push_back(infinite_loop); + } while (code_mem.size() % 2 != 0); + } + + bool IsInCodeMem(u32 vaddr) const { + return vaddr < sizeof(InstructionType) * code_mem.size(); + } + + std::optional<std::uint32_t> MemoryReadCode(u32 vaddr) override { + if (IsInCodeMem(vaddr)) { + u32 value; + std::memcpy(&value, &code_mem[vaddr / sizeof(InstructionType)], sizeof(u32)); + return value; + } + return infinite_loop_u32; // B . + } + + std::uint8_t MemoryRead8(u32 vaddr) override { + if (IsInCodeMem(vaddr)) { + return reinterpret_cast<u8*>(code_mem.data())[vaddr]; + } + if (auto iter = modified_memory.find(vaddr); iter != modified_memory.end()) { + return iter->second; + } + return static_cast<u8>(vaddr); + } + std::uint16_t MemoryRead16(u32 vaddr) override { + return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8; + } + std::uint32_t MemoryRead32(u32 vaddr) override { + return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16; + } + std::uint64_t MemoryRead64(u32 vaddr) override { + return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32; + } + + void MemoryWrite8(u32 vaddr, std::uint8_t value) override { + if (vaddr < code_mem.size() * sizeof(u32)) { + code_mem_modified_by_guest = true; + } + modified_memory[vaddr] = value; + } + void MemoryWrite16(u32 vaddr, std::uint16_t value) override { + MemoryWrite8(vaddr, static_cast<u8>(value)); + MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8)); + } + void MemoryWrite32(u32 vaddr, std::uint32_t value) override { + MemoryWrite16(vaddr, static_cast<u16>(value)); + MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16)); + } + void MemoryWrite64(u32 vaddr, std::uint64_t value) override { + MemoryWrite32(vaddr, static_cast<u32>(value)); + MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32)); + } + + void InterpreterFallback(u32 pc, size_t num_instructions) override { ASSERT_MSG(false, "InterpreterFallback({:08x}, {}) code = {:08x}", pc, num_instructions, *MemoryReadCode(pc)); } + + void CallSVC(std::uint32_t swi) override { ASSERT_MSG(false, "CallSVC({})", swi); } + + void ExceptionRaised(u32 pc, Dynarmic::A32::Exception /*exception*/) override { ASSERT_MSG(false, "ExceptionRaised({:08x}) code = {:08x}", pc, *MemoryReadCode(pc)); } + + void AddTicks(std::uint64_t ticks) override { + if (ticks > ticks_left) { + ticks_left = 0; + return; + } + ticks_left -= ticks; + } + std::uint64_t GetTicksRemaining() override { + return ticks_left; + } +}; + +using ArmTestEnv = A32TestEnv<u32, 0xEAFFFFFE>; +using ThumbTestEnv = A32TestEnv<u16, 0xE7FEE7FE>; + +class A32FastmemTestEnv final : public Dynarmic::A32::UserCallbacks { +public: + u64 ticks_left = 0; + char* backing_memory = nullptr; + + explicit A32FastmemTestEnv(char* addr) + : backing_memory(addr) {} + + template<typename T> + T read(std::uint32_t vaddr) { + T value; + memcpy(&value, backing_memory + vaddr, sizeof(T)); + return value; + } + template<typename T> + void write(std::uint32_t vaddr, const T& value) { + memcpy(backing_memory + vaddr, &value, sizeof(T)); + } + + std::optional<std::uint32_t> MemoryReadCode(std::uint32_t vaddr) override { + return read<std::uint32_t>(vaddr); + } + + std::uint8_t MemoryRead8(std::uint32_t vaddr) override { + return read<std::uint8_t>(vaddr); + } + std::uint16_t MemoryRead16(std::uint32_t vaddr) override { + return read<std::uint16_t>(vaddr); + } + std::uint32_t MemoryRead32(std::uint32_t vaddr) override { + return read<std::uint32_t>(vaddr); + } + std::uint64_t MemoryRead64(std::uint32_t vaddr) override { + return read<std::uint64_t>(vaddr); + } + + void MemoryWrite8(std::uint32_t vaddr, std::uint8_t value) override { + write(vaddr, value); + } + void MemoryWrite16(std::uint32_t vaddr, std::uint16_t value) override { + write(vaddr, value); + } + void MemoryWrite32(std::uint32_t vaddr, std::uint32_t value) override { + write(vaddr, value); + } + void MemoryWrite64(std::uint32_t vaddr, std::uint64_t value) override { + write(vaddr, value); + } + + bool MemoryWriteExclusive8(std::uint32_t vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override { + MemoryWrite8(vaddr, value); + return true; + } + bool MemoryWriteExclusive16(std::uint32_t vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override { + MemoryWrite16(vaddr, value); + return true; + } + bool MemoryWriteExclusive32(std::uint32_t vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override { + MemoryWrite32(vaddr, value); + return true; + } + bool MemoryWriteExclusive64(std::uint32_t vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override { + MemoryWrite64(vaddr, value); + return true; + } + + void InterpreterFallback(std::uint32_t pc, size_t num_instructions) override { ASSERT_MSG(false, "InterpreterFallback({:016x}, {})", pc, num_instructions); } + + void CallSVC(std::uint32_t swi) override { ASSERT_MSG(false, "CallSVC({})", swi); } + + void ExceptionRaised(std::uint32_t pc, Dynarmic::A32::Exception) override { ASSERT_MSG(false, "ExceptionRaised({:016x})", pc); } + + void AddTicks(std::uint64_t ticks) override { + if (ticks > ticks_left) { + ticks_left = 0; + return; + } + ticks_left -= ticks; + } + std::uint64_t GetTicksRemaining() override { + return ticks_left; + } +}; diff --git a/externals/dynarmic/tests/A32/vfp_vadd_f32.inc b/externals/dynarmic/tests/A32/vfp_vadd_f32.inc new file mode 100644 index 0000000000..d0032c2e65 --- /dev/null +++ b/externals/dynarmic/tests/A32/vfp_vadd_f32.inc @@ -0,0 +1,13456 @@ +{0x3c00000, 0x0, 0x0, 0x0, 0x3c00000}, +{0x3c00000, 0x0, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x800000, 0x800000, 0x3c00000}, +{0x3c00000, 0x0, 0x800002, 0x800002, 0x3c00000}, +{0x3c00000, 0x0, 0x1398437, 0x1398437, 0x3c00000}, +{0x3c00000, 0x0, 0xba98d27, 0xba98d27, 0x3c00000}, +{0x3c00000, 0x0, 0xba98d7a, 0xba98d7a, 0x3c00000}, +{0x3c00000, 0x0, 0x751f853a, 0x751f853a, 0x3c00000}, +{0x3c00000, 0x0, 0x7f7ffff0, 0x7f7ffff0, 0x3c00000}, +{0x3c00000, 0x0, 0x7f7fffff, 0x7f7fffff, 0x3c00000}, +{0x3c00000, 0x0, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x0, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0x80000000, 0x0, 0x3c00000}, +{0x3c00000, 0x0, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x80800000, 0x80800000, 0x3c00000}, +{0x3c00000, 0x0, 0x80800002, 0x80800002, 0x3c00000}, +{0x3c00000, 0x0, 0x81398437, 0x81398437, 0x3c00000}, +{0x3c00000, 0x0, 0x8ba98d27, 0x8ba98d27, 0x3c00000}, +{0x3c00000, 0x0, 0x8ba98d7a, 0x8ba98d7a, 0x3c00000}, +{0x3c00000, 0x0, 0xf51f853a, 0xf51f853a, 0x3c00000}, +{0x3c00000, 0x0, 0xff7ffff0, 0xff7ffff0, 0x3c00000}, +{0x3c00000, 0x0, 0xff7fffff, 0xff7fffff, 0x3c00000}, +{0x3c00000, 0x0, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x0, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0x4f3495cb, 0x4f3495cb, 0x3c00000}, +{0x3c00000, 0x0, 0xe73a5134, 0xe73a5134, 0x3c00000}, +{0x3c00000, 0x0, 0x7c994e9e, 0x7c994e9e, 0x3c00000}, +{0x3c00000, 0x0, 0x6164bd6c, 0x6164bd6c, 0x3c00000}, +{0x3c00000, 0x0, 0x9503366, 0x9503366, 0x3c00000}, +{0x3c00000, 0x0, 0xbf5a97c9, 0xbf5a97c9, 0x3c00000}, +{0x3c00000, 0x0, 0xe6ff1a14, 0xe6ff1a14, 0x3c00000}, +{0x3c00000, 0x0, 0x77f31e2f, 0x77f31e2f, 0x3c00000}, +{0x3c00000, 0x0, 0xaab4d7d8, 0xaab4d7d8, 0x3c00000}, +{0x3c00000, 0x0, 0x966320b, 0x966320b, 0x3c00000}, +{0x3c00000, 0x0, 0xb26bddee, 0xb26bddee, 0x3c00000}, +{0x3c00000, 0x0, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00000}, +{0x3c00000, 0x0, 0x317285d3, 0x317285d3, 0x3c00000}, +{0x3c00000, 0x0, 0x3c9623b1, 0x3c9623b1, 0x3c00000}, +{0x3c00000, 0x0, 0x51fd2c7c, 0x51fd2c7c, 0x3c00000}, +{0x3c00000, 0x0, 0x7b906a6c, 0x7b906a6c, 0x3c00000}, +{0x3c00000, 0x1, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x1, 0x800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x1, 0x1398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1, 0xba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x1, 0xba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x1, 0x751f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x1, 0x7f7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x1, 0x7f7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x1, 0x7f800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x1, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x80800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x1, 0x80800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x1, 0x81398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x1, 0x8ba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x1, 0x8ba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x1, 0xf51f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x1, 0xff7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x1, 0xff7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x1, 0xff800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x1, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0x4f3495cb, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x1, 0xe73a5134, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0x1, 0x7c994e9e, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x1, 0x6164bd6c, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x1, 0x9503366, 0x9503366, 0x3c00080}, +{0x3c00000, 0x1, 0xbf5a97c9, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0x1, 0xe6ff1a14, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0x1, 0x77f31e2f, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x1, 0xaab4d7d8, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0x1, 0x966320b, 0x966320b, 0x3c00080}, +{0x3c00000, 0x1, 0xb26bddee, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0x1, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0x1, 0x317285d3, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x1, 0x3c9623b1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x1, 0x51fd2c7c, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x1, 0x7b906a6c, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x76, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x76, 0x800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x76, 0x1398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x76, 0xba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x76, 0xba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x76, 0x751f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x76, 0x7f7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x76, 0x7f7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x76, 0x7f800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x76, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x80800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x76, 0x80800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x76, 0x81398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x76, 0x8ba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x76, 0x8ba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x76, 0xf51f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x76, 0xff7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x76, 0xff7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x76, 0xff800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x76, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0x4f3495cb, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x76, 0xe73a5134, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0x76, 0x7c994e9e, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x76, 0x6164bd6c, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x76, 0x9503366, 0x9503366, 0x3c00080}, +{0x3c00000, 0x76, 0xbf5a97c9, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0x76, 0xe6ff1a14, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0x76, 0x77f31e2f, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x76, 0xaab4d7d8, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0x76, 0x966320b, 0x966320b, 0x3c00080}, +{0x3c00000, 0x76, 0xb26bddee, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0x76, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0x76, 0x317285d3, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x76, 0x3c9623b1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x76, 0x51fd2c7c, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x76, 0x7b906a6c, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x2b94, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x2b94, 0x1398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x2b94, 0xba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x2b94, 0xba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x2b94, 0x751f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7f7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7f7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7f800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x2b94, 0x81398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x2b94, 0x8ba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x2b94, 0x8ba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x2b94, 0xf51f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x2b94, 0xff7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x2b94, 0xff7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x2b94, 0xff800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x2b94, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x4f3495cb, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x2b94, 0xe73a5134, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7c994e9e, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x2b94, 0x6164bd6c, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x2b94, 0x9503366, 0x9503366, 0x3c00080}, +{0x3c00000, 0x2b94, 0xbf5a97c9, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0x2b94, 0xe6ff1a14, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0x2b94, 0x77f31e2f, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x2b94, 0xaab4d7d8, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0x2b94, 0x966320b, 0x966320b, 0x3c00080}, +{0x3c00000, 0x2b94, 0xb26bddee, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0x2b94, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0x2b94, 0x317285d3, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x2b94, 0x3c9623b1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x2b94, 0x51fd2c7c, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7b906a6c, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x636d24, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x636d24, 0x1398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x636d24, 0xba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x636d24, 0xba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x636d24, 0x751f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7f7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7f7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7f800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x636d24, 0x81398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x636d24, 0x8ba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x636d24, 0x8ba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x636d24, 0xf51f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x636d24, 0xff7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x636d24, 0xff7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x636d24, 0xff800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x636d24, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x4f3495cb, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x636d24, 0xe73a5134, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7c994e9e, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x636d24, 0x6164bd6c, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x636d24, 0x9503366, 0x9503366, 0x3c00080}, +{0x3c00000, 0x636d24, 0xbf5a97c9, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0x636d24, 0xe6ff1a14, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0x636d24, 0x77f31e2f, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x636d24, 0xaab4d7d8, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0x636d24, 0x966320b, 0x966320b, 0x3c00080}, +{0x3c00000, 0x636d24, 0xb26bddee, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0x636d24, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0x636d24, 0x317285d3, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x636d24, 0x3c9623b1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x636d24, 0x51fd2c7c, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7b906a6c, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x1398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x751f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7f7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7f7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7f800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x81398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x8ba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x8ba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xf51f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xff7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xff7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xff800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x4f3495cb, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xe73a5134, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7c994e9e, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x6164bd6c, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x9503366, 0x9503366, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xbf5a97c9, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xe6ff1a14, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x77f31e2f, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xaab4d7d8, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x966320b, 0x966320b, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xb26bddee, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x317285d3, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x3c9623b1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x51fd2c7c, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7b906a6c, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x800000, 0x0, 0x800000, 0x3c00000}, +{0x3c00000, 0x800000, 0x1, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x76, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x2b94, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x636d24, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x7fffff, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x800000, 0x1000000, 0x3c00000}, +{0x3c00000, 0x800000, 0x800002, 0x1000001, 0x3c00000}, +{0x3c00000, 0x800000, 0x1398437, 0x1798437, 0x3c00000}, +{0x3c00000, 0x800000, 0xba98d27, 0xba98d29, 0x3c00000}, +{0x3c00000, 0x800000, 0xba98d7a, 0xba98d7c, 0x3c00000}, +{0x3c00000, 0x800000, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x800000, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x800000, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x800000, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x800000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0x80000000, 0x800000, 0x3c00000}, +{0x3c00000, 0x800000, 0x80000001, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x80000076, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x80002b94, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x80636d24, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x807fffff, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x80800000, 0x0, 0x3c00000}, +{0x3c00000, 0x800000, 0x80800002, 0x0, 0x3c00008}, +{0x3c00000, 0x800000, 0x81398437, 0x80f3086e, 0x3c00000}, +{0x3c00000, 0x800000, 0x8ba98d27, 0x8ba98d25, 0x3c00000}, +{0x3c00000, 0x800000, 0x8ba98d7a, 0x8ba98d78, 0x3c00000}, +{0x3c00000, 0x800000, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x800000, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x800000, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x800000, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x800000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0x4f3495cb, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x800000, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0x800000, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x800000, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x800000, 0x9503366, 0x95033a6, 0x3c00000}, +{0x3c00000, 0x800000, 0xbf5a97c9, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0x800000, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0x800000, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x800000, 0xaab4d7d8, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0x800000, 0x966320b, 0x966324b, 0x3c00000}, +{0x3c00000, 0x800000, 0xb26bddee, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0x800000, 0xb5c8e5d3, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0x800000, 0x317285d3, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x800000, 0x3c9623b1, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x800000, 0x51fd2c7c, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x800000, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x800002, 0x0, 0x800002, 0x3c00000}, +{0x3c00000, 0x800002, 0x1, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x76, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x2b94, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x636d24, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x7fffff, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x800000, 0x1000001, 0x3c00000}, +{0x3c00000, 0x800002, 0x800002, 0x1000002, 0x3c00000}, +{0x3c00000, 0x800002, 0x1398437, 0x1798438, 0x3c00000}, +{0x3c00000, 0x800002, 0xba98d27, 0xba98d29, 0x3c00010}, +{0x3c00000, 0x800002, 0xba98d7a, 0xba98d7c, 0x3c00010}, +{0x3c00000, 0x800002, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x800002, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x800002, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x800002, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x800002, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0x80000000, 0x800002, 0x3c00000}, +{0x3c00000, 0x800002, 0x80000001, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x80000076, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x80002b94, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x80636d24, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x807fffff, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x80800000, 0x0, 0x3c00008}, +{0x3c00000, 0x800002, 0x80800002, 0x0, 0x3c00000}, +{0x3c00000, 0x800002, 0x81398437, 0x80f3086c, 0x3c00000}, +{0x3c00000, 0x800002, 0x8ba98d27, 0x8ba98d24, 0x3c00010}, +{0x3c00000, 0x800002, 0x8ba98d7a, 0x8ba98d77, 0x3c00010}, +{0x3c00000, 0x800002, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x800002, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x800002, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x800002, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x800002, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0x4f3495cb, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x800002, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0x800002, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x800002, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x800002, 0x9503366, 0x95033a6, 0x3c00010}, +{0x3c00000, 0x800002, 0xbf5a97c9, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0x800002, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0x800002, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x800002, 0xaab4d7d8, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0x800002, 0x966320b, 0x966324b, 0x3c00010}, +{0x3c00000, 0x800002, 0xb26bddee, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0x800002, 0xb5c8e5d3, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0x800002, 0x317285d3, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x800002, 0x3c9623b1, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x800002, 0x51fd2c7c, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x800002, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x1398437, 0x0, 0x1398437, 0x3c00000}, +{0x3c00000, 0x1398437, 0x1, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x76, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x2b94, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x636d24, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x7fffff, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x800000, 0x1798437, 0x3c00000}, +{0x3c00000, 0x1398437, 0x800002, 0x1798438, 0x3c00000}, +{0x3c00000, 0x1398437, 0x1398437, 0x1b98437, 0x3c00000}, +{0x3c00000, 0x1398437, 0xba98d27, 0xba98d2c, 0x3c00010}, +{0x3c00000, 0x1398437, 0xba98d7a, 0xba98d7f, 0x3c00010}, +{0x3c00000, 0x1398437, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x1398437, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x1398437, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x1398437, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x1398437, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0x80000000, 0x1398437, 0x3c00000}, +{0x3c00000, 0x1398437, 0x80000001, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x80000076, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x80002b94, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x80636d24, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x807fffff, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x80800000, 0xf3086e, 0x3c00000}, +{0x3c00000, 0x1398437, 0x80800002, 0xf3086c, 0x3c00000}, +{0x3c00000, 0x1398437, 0x81398437, 0x0, 0x3c00000}, +{0x3c00000, 0x1398437, 0x8ba98d27, 0x8ba98d21, 0x3c00010}, +{0x3c00000, 0x1398437, 0x8ba98d7a, 0x8ba98d74, 0x3c00010}, +{0x3c00000, 0x1398437, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x1398437, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x1398437, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x1398437, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x1398437, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0x4f3495cb, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x1398437, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0x1398437, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x1398437, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x1398437, 0x9503366, 0x950341f, 0x3c00010}, +{0x3c00000, 0x1398437, 0xbf5a97c9, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0x1398437, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0x1398437, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x1398437, 0xaab4d7d8, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0x1398437, 0x966320b, 0x96632c4, 0x3c00010}, +{0x3c00000, 0x1398437, 0xb26bddee, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0x1398437, 0xb5c8e5d3, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0x1398437, 0x317285d3, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x1398437, 0x3c9623b1, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x1398437, 0x51fd2c7c, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x1398437, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x0, 0xba98d27, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x1, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x76, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x2b94, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x636d24, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x7fffff, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x800000, 0xba98d29, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x800002, 0xba98d29, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x1398437, 0xba98d2c, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xba98d27, 0xc298d27, 0x3c00000}, +{0x3c00000, 0xba98d27, 0xba98d7a, 0xc298d50, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x80000000, 0xba98d27, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x80000001, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x80000076, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x80002b94, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x80636d24, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x807fffff, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x80800000, 0xba98d25, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x80800002, 0xba98d24, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x81398437, 0xba98d21, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x8ba98d27, 0x0, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x8ba98d7a, 0x83260000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x4f3495cb, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x9503366, 0xbb00ec2, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xbf5a97c9, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xaab4d7d8, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x966320b, 0xbb0beb7, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xb26bddee, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xb5c8e5d3, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x317285d3, 0x317285d3, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x3c9623b1, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x51fd2c7c, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x0, 0xba98d7a, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x1, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x76, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x2b94, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x636d24, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x7fffff, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x800000, 0xba98d7c, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x800002, 0xba98d7c, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x1398437, 0xba98d7f, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xba98d27, 0xc298d50, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xba98d7a, 0xc298d7a, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x80000000, 0xba98d7a, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x80000001, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x80000076, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x80002b94, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x80636d24, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x807fffff, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x80800000, 0xba98d78, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x80800002, 0xba98d77, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x81398437, 0xba98d74, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x8ba98d27, 0x3260000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x8ba98d7a, 0x0, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x4f3495cb, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x9503366, 0xbb00f15, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xbf5a97c9, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xaab4d7d8, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x966320b, 0xbb0bf0a, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xb26bddee, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xb5c8e5d3, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x317285d3, 0x317285d3, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x3c9623b1, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x51fd2c7c, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x0, 0x751f853a, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x1, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x76, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x2b94, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x636d24, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x7fffff, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x800000, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x800002, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x1398437, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xba98d27, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xba98d7a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x751f853a, 0x759f853a, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x7f7ffff0, 0x7f7ffff9, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x7f7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x751f853a, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x80000000, 0x751f853a, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x80000001, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x80000076, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x80002b94, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x80636d24, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x807fffff, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x80800000, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x80800002, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x81398437, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x8ba98d27, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x8ba98d7a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xf51f853a, 0x0, 0x3c00000}, +{0x3c00000, 0x751f853a, 0xff7ffff0, 0xff7fffe6, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xff7fffff, 0xff7ffff5, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x4f3495cb, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xe73a5134, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x7c994e9e, 0x7c994fdd, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x6164bd6c, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x9503366, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xbf5a97c9, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xe6ff1a14, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x77f31e2f, 0x77f81a58, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xaab4d7d8, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x966320b, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xb26bddee, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xb5c8e5d3, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x317285d3, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x3c9623b1, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x51fd2c7c, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x7b906a6c, 0x7b906f68, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x0, 0x7f7ffff0, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x1, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x76, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x2b94, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x636d24, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x7fffff, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x800000, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x800002, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x1398437, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xba98d27, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xba98d7a, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x751f853a, 0x7f7ffff9, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x7f7ffff0, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7ffff0, 0x7f7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7ffff0, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x80000000, 0x7f7ffff0, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x80000001, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x80000076, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x80002b94, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x80636d24, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x807fffff, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x80800000, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x80800002, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x81398437, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x8ba98d27, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x8ba98d7a, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xf51f853a, 0x7f7fffe6, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xff7ffff0, 0x0, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0xff7fffff, 0xf5700000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x4f3495cb, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xe73a5134, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x7c994e9e, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7ffff0, 0x6164bd6c, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x9503366, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xbf5a97c9, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xe6ff1a14, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x77f31e2f, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7ffff0, 0xaab4d7d8, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x966320b, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xb26bddee, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xb5c8e5d3, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x317285d3, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x3c9623b1, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x51fd2c7c, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x7b906a6c, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7fffff, 0x0, 0x7f7fffff, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x1, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x76, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x2b94, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x636d24, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x800000, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x800002, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x1398437, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xba98d27, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xba98d7a, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x751f853a, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7fffff, 0x7f7ffff0, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7fffff, 0x7f7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7fffff, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x80000000, 0x7f7fffff, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x80000001, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x80000076, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x80002b94, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x80636d24, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x807fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x80800000, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x80800002, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x81398437, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x8ba98d27, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x8ba98d7a, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xf51f853a, 0x7f7ffff5, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xff7ffff0, 0x75700000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0xff7fffff, 0x0, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x4f3495cb, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xe73a5134, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x7c994e9e, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7fffff, 0x6164bd6c, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x9503366, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xbf5a97c9, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xe6ff1a14, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x77f31e2f, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7fffff, 0xaab4d7d8, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x966320b, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xb26bddee, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xb5c8e5d3, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x317285d3, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x3c9623b1, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x51fd2c7c, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x7b906a6c, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f800000, 0x0, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x1, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x76, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x2b94, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x636d24, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x7fffff, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x800002, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x1398437, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xba98d27, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xba98d7a, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x751f853a, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7f7ffff0, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7f7fffff, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x80000000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x80000001, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x80000076, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x80002b94, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x80636d24, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x807fffff, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x80800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x80800002, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x81398437, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x8ba98d27, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x8ba98d7a, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xf51f853a, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xff7ffff0, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xff7fffff, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x4f3495cb, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xe73a5134, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7c994e9e, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x6164bd6c, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x9503366, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xbf5a97c9, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xe6ff1a14, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x77f31e2f, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xaab4d7d8, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x966320b, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xb26bddee, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xb5c8e5d3, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x317285d3, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x3c9623b1, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x51fd2c7c, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7b906a6c, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800001, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x0, 0x0, 0x3c00000}, +{0x3c00000, 0x80000000, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x80000000, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x80000000, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80000000, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80000000, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80000000, 0x800000, 0x800000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x800002, 0x800002, 0x3c00000}, +{0x3c00000, 0x80000000, 0x1398437, 0x1398437, 0x3c00000}, +{0x3c00000, 0x80000000, 0xba98d27, 0xba98d27, 0x3c00000}, +{0x3c00000, 0x80000000, 0xba98d7a, 0xba98d7a, 0x3c00000}, +{0x3c00000, 0x80000000, 0x751f853a, 0x751f853a, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7f7ffff0, 0x7f7ffff0, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7f7fffff, 0x7f7fffff, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x80000000, 0x80000000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x80000000, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x80000000, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80000000, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80000000, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80000000, 0x80800000, 0x80800000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x80800002, 0x80800002, 0x3c00000}, +{0x3c00000, 0x80000000, 0x81398437, 0x81398437, 0x3c00000}, +{0x3c00000, 0x80000000, 0x8ba98d27, 0x8ba98d27, 0x3c00000}, +{0x3c00000, 0x80000000, 0x8ba98d7a, 0x8ba98d7a, 0x3c00000}, +{0x3c00000, 0x80000000, 0xf51f853a, 0xf51f853a, 0x3c00000}, +{0x3c00000, 0x80000000, 0xff7ffff0, 0xff7ffff0, 0x3c00000}, +{0x3c00000, 0x80000000, 0xff7fffff, 0xff7fffff, 0x3c00000}, +{0x3c00000, 0x80000000, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x80000000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x4f3495cb, 0x4f3495cb, 0x3c00000}, +{0x3c00000, 0x80000000, 0xe73a5134, 0xe73a5134, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7c994e9e, 0x7c994e9e, 0x3c00000}, +{0x3c00000, 0x80000000, 0x6164bd6c, 0x6164bd6c, 0x3c00000}, +{0x3c00000, 0x80000000, 0x9503366, 0x9503366, 0x3c00000}, +{0x3c00000, 0x80000000, 0xbf5a97c9, 0xbf5a97c9, 0x3c00000}, +{0x3c00000, 0x80000000, 0xe6ff1a14, 0xe6ff1a14, 0x3c00000}, +{0x3c00000, 0x80000000, 0x77f31e2f, 0x77f31e2f, 0x3c00000}, +{0x3c00000, 0x80000000, 0xaab4d7d8, 0xaab4d7d8, 0x3c00000}, +{0x3c00000, 0x80000000, 0x966320b, 0x966320b, 0x3c00000}, +{0x3c00000, 0x80000000, 0xb26bddee, 0xb26bddee, 0x3c00000}, +{0x3c00000, 0x80000000, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00000}, +{0x3c00000, 0x80000000, 0x317285d3, 0x317285d3, 0x3c00000}, +{0x3c00000, 0x80000000, 0x3c9623b1, 0x3c9623b1, 0x3c00000}, +{0x3c00000, 0x80000000, 0x51fd2c7c, 0x51fd2c7c, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7b906a6c, 0x7b906a6c, 0x3c00000}, +{0x3c00000, 0x80000001, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x80000001, 0x1398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x80000001, 0xba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x80000001, 0xba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x80000001, 0x751f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7f7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7f7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7f800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80000001, 0x81398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x80000001, 0x8ba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x80000001, 0x8ba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x80000001, 0xf51f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x80000001, 0xff7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x80000001, 0xff7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x80000001, 0xff800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x80000001, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x4f3495cb, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x80000001, 0xe73a5134, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7c994e9e, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x80000001, 0x6164bd6c, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x80000001, 0x9503366, 0x9503366, 0x3c00080}, +{0x3c00000, 0x80000001, 0xbf5a97c9, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0x80000001, 0xe6ff1a14, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0x80000001, 0x77f31e2f, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x80000001, 0xaab4d7d8, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0x80000001, 0x966320b, 0x966320b, 0x3c00080}, +{0x3c00000, 0x80000001, 0xb26bddee, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0x80000001, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0x80000001, 0x317285d3, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x80000001, 0x3c9623b1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x80000001, 0x51fd2c7c, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7b906a6c, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x80000076, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x80000076, 0x1398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x80000076, 0xba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x80000076, 0xba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x80000076, 0x751f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7f7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7f7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7f800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80000076, 0x81398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x80000076, 0x8ba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x80000076, 0x8ba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x80000076, 0xf51f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x80000076, 0xff7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x80000076, 0xff7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x80000076, 0xff800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x80000076, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x4f3495cb, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x80000076, 0xe73a5134, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7c994e9e, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x80000076, 0x6164bd6c, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x80000076, 0x9503366, 0x9503366, 0x3c00080}, +{0x3c00000, 0x80000076, 0xbf5a97c9, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0x80000076, 0xe6ff1a14, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0x80000076, 0x77f31e2f, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x80000076, 0xaab4d7d8, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0x80000076, 0x966320b, 0x966320b, 0x3c00080}, +{0x3c00000, 0x80000076, 0xb26bddee, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0x80000076, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0x80000076, 0x317285d3, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x80000076, 0x3c9623b1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x80000076, 0x51fd2c7c, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7b906a6c, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x1398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x751f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7f7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7f7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7f800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x81398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x8ba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x8ba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xf51f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xff7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xff7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xff800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x4f3495cb, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xe73a5134, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7c994e9e, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x6164bd6c, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x9503366, 0x9503366, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xbf5a97c9, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xe6ff1a14, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x77f31e2f, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xaab4d7d8, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x966320b, 0x966320b, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xb26bddee, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x317285d3, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x3c9623b1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x51fd2c7c, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7b906a6c, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x1398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x751f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7f7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7f7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7f800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x81398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x8ba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x8ba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xf51f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xff7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xff7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xff800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x4f3495cb, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xe73a5134, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7c994e9e, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x6164bd6c, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x9503366, 0x9503366, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xbf5a97c9, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xe6ff1a14, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x77f31e2f, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xaab4d7d8, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x966320b, 0x966320b, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xb26bddee, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x317285d3, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x3c9623b1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x51fd2c7c, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7b906a6c, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x1398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x751f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7f7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7f7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7f800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x81398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x8ba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x8ba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xf51f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xff7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xff7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xff800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x4f3495cb, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xe73a5134, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7c994e9e, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x6164bd6c, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x9503366, 0x9503366, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xbf5a97c9, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xe6ff1a14, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x77f31e2f, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xaab4d7d8, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x966320b, 0x966320b, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xb26bddee, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x317285d3, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x3c9623b1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x51fd2c7c, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7b906a6c, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x80800000, 0x0, 0x80800000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x1, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x76, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x2b94, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x636d24, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x7fffff, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x800000, 0x0, 0x3c00000}, +{0x3c00000, 0x80800000, 0x800002, 0x0, 0x3c00008}, +{0x3c00000, 0x80800000, 0x1398437, 0xf3086e, 0x3c00000}, +{0x3c00000, 0x80800000, 0xba98d27, 0xba98d25, 0x3c00000}, +{0x3c00000, 0x80800000, 0xba98d7a, 0xba98d78, 0x3c00000}, +{0x3c00000, 0x80800000, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x80800000, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x80800000, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x80800000, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x80000000, 0x80800000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x80000001, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x80000076, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x80002b94, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x80636d24, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x807fffff, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x80800000, 0x81000000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x80800002, 0x81000001, 0x3c00000}, +{0x3c00000, 0x80800000, 0x81398437, 0x81798437, 0x3c00000}, +{0x3c00000, 0x80800000, 0x8ba98d27, 0x8ba98d29, 0x3c00000}, +{0x3c00000, 0x80800000, 0x8ba98d7a, 0x8ba98d7c, 0x3c00000}, +{0x3c00000, 0x80800000, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0x80800000, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0x80800000, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0x80800000, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x80800000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x4f3495cb, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x80800000, 0xe73a5134, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0x80800000, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x80800000, 0x6164bd6c, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x80800000, 0x9503366, 0x9503326, 0x3c00000}, +{0x3c00000, 0x80800000, 0xbf5a97c9, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0x80800000, 0xe6ff1a14, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0x80800000, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x80800000, 0xaab4d7d8, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0x80800000, 0x966320b, 0x96631cb, 0x3c00000}, +{0x3c00000, 0x80800000, 0xb26bddee, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0x80800000, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0x80800000, 0x317285d3, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x80800000, 0x3c9623b1, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x80800000, 0x51fd2c7c, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x80800000, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x80800002, 0x0, 0x80800002, 0x3c00000}, +{0x3c00000, 0x80800002, 0x1, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x76, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x2b94, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x636d24, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x7fffff, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x800000, 0x0, 0x3c00008}, +{0x3c00000, 0x80800002, 0x800002, 0x0, 0x3c00000}, +{0x3c00000, 0x80800002, 0x1398437, 0xf3086c, 0x3c00000}, +{0x3c00000, 0x80800002, 0xba98d27, 0xba98d24, 0x3c00010}, +{0x3c00000, 0x80800002, 0xba98d7a, 0xba98d77, 0x3c00010}, +{0x3c00000, 0x80800002, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x80800002, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x80800002, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x80800002, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x80800002, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0x80000000, 0x80800002, 0x3c00000}, +{0x3c00000, 0x80800002, 0x80000001, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x80000076, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x80002b94, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x80636d24, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x807fffff, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x80800000, 0x81000001, 0x3c00000}, +{0x3c00000, 0x80800002, 0x80800002, 0x81000002, 0x3c00000}, +{0x3c00000, 0x80800002, 0x81398437, 0x81798438, 0x3c00000}, +{0x3c00000, 0x80800002, 0x8ba98d27, 0x8ba98d29, 0x3c00010}, +{0x3c00000, 0x80800002, 0x8ba98d7a, 0x8ba98d7c, 0x3c00010}, +{0x3c00000, 0x80800002, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0x80800002, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0x80800002, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0x80800002, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x80800002, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0x4f3495cb, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x80800002, 0xe73a5134, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0x80800002, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x80800002, 0x6164bd6c, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x80800002, 0x9503366, 0x9503325, 0x3c00010}, +{0x3c00000, 0x80800002, 0xbf5a97c9, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0x80800002, 0xe6ff1a14, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0x80800002, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x80800002, 0xaab4d7d8, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0x80800002, 0x966320b, 0x96631ca, 0x3c00010}, +{0x3c00000, 0x80800002, 0xb26bddee, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0x80800002, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0x80800002, 0x317285d3, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x80800002, 0x3c9623b1, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x80800002, 0x51fd2c7c, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x80800002, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x81398437, 0x0, 0x81398437, 0x3c00000}, +{0x3c00000, 0x81398437, 0x1, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x76, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x2b94, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x636d24, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x7fffff, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x800000, 0x80f3086e, 0x3c00000}, +{0x3c00000, 0x81398437, 0x800002, 0x80f3086c, 0x3c00000}, +{0x3c00000, 0x81398437, 0x1398437, 0x0, 0x3c00000}, +{0x3c00000, 0x81398437, 0xba98d27, 0xba98d21, 0x3c00010}, +{0x3c00000, 0x81398437, 0xba98d7a, 0xba98d74, 0x3c00010}, +{0x3c00000, 0x81398437, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x81398437, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x81398437, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x81398437, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x81398437, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0x80000000, 0x81398437, 0x3c00000}, +{0x3c00000, 0x81398437, 0x80000001, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x80000076, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x80002b94, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x80636d24, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x807fffff, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x80800000, 0x81798437, 0x3c00000}, +{0x3c00000, 0x81398437, 0x80800002, 0x81798438, 0x3c00000}, +{0x3c00000, 0x81398437, 0x81398437, 0x81b98437, 0x3c00000}, +{0x3c00000, 0x81398437, 0x8ba98d27, 0x8ba98d2c, 0x3c00010}, +{0x3c00000, 0x81398437, 0x8ba98d7a, 0x8ba98d7f, 0x3c00010}, +{0x3c00000, 0x81398437, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0x81398437, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0x81398437, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0x81398437, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x81398437, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0x4f3495cb, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x81398437, 0xe73a5134, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0x81398437, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x81398437, 0x6164bd6c, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x81398437, 0x9503366, 0x95032ac, 0x3c00010}, +{0x3c00000, 0x81398437, 0xbf5a97c9, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0x81398437, 0xe6ff1a14, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0x81398437, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x81398437, 0xaab4d7d8, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0x81398437, 0x966320b, 0x9663151, 0x3c00010}, +{0x3c00000, 0x81398437, 0xb26bddee, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0x81398437, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0x81398437, 0x317285d3, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x81398437, 0x3c9623b1, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x81398437, 0x51fd2c7c, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x81398437, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x0, 0x8ba98d27, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x1, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x76, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x2b94, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x636d24, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x7fffff, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x800000, 0x8ba98d25, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x800002, 0x8ba98d24, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x1398437, 0x8ba98d21, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xba98d27, 0x0, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0xba98d7a, 0x3260000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x80000000, 0x8ba98d27, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x80000001, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x80000076, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x80002b94, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x80636d24, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x807fffff, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x80800000, 0x8ba98d29, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x80800002, 0x8ba98d29, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x81398437, 0x8ba98d2c, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x8ba98d27, 0x8c298d27, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x8ba98d7a, 0x8c298d50, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x4f3495cb, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xe73a5134, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x6164bd6c, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x9503366, 0x8ba30b8b, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xbf5a97c9, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xe6ff1a14, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xaab4d7d8, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x966320b, 0x8ba25b96, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xb26bddee, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x317285d3, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x3c9623b1, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x51fd2c7c, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x0, 0x8ba98d7a, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x1, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x76, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x2b94, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x636d24, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x7fffff, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x800000, 0x8ba98d78, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x800002, 0x8ba98d77, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x1398437, 0x8ba98d74, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xba98d27, 0x83260000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0xba98d7a, 0x0, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x80000000, 0x8ba98d7a, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x80000001, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x80000076, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x80002b94, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x80636d24, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x807fffff, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x80800000, 0x8ba98d7c, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x80800002, 0x8ba98d7c, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x81398437, 0x8ba98d7f, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x8ba98d27, 0x8c298d50, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x8ba98d7a, 0x8c298d7a, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x4f3495cb, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xe73a5134, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x6164bd6c, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x9503366, 0x8ba30bde, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xbf5a97c9, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xe6ff1a14, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xaab4d7d8, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x966320b, 0x8ba25be9, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xb26bddee, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xb5c8e5d3, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x317285d3, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x3c9623b1, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x51fd2c7c, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x0, 0xf51f853a, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x1, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x76, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x2b94, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x636d24, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x7fffff, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x800000, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x800002, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x1398437, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xba98d27, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xba98d7a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x751f853a, 0x0, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x7f7ffff0, 0x7f7fffe6, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x7f7fffff, 0x7f7ffff5, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x80000000, 0xf51f853a, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x80000001, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x80000076, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x80002b94, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x80636d24, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x807fffff, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x80800000, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x80800002, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x81398437, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x8ba98d27, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x8ba98d7a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xf51f853a, 0xf59f853a, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0xff7ffff0, 0xff7ffff9, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xff7fffff, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xf51f853a, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x4f3495cb, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xe73a5134, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x7c994e9e, 0x7c994d5e, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x6164bd6c, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x9503366, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xbf5a97c9, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xe6ff1a14, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x77f31e2f, 0x77ee2205, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xaab4d7d8, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x966320b, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xb26bddee, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xb5c8e5d3, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x317285d3, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x3c9623b1, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x51fd2c7c, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x7b906a6c, 0x7b90656f, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x0, 0xff7ffff0, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x1, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x76, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x2b94, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x636d24, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x7fffff, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x800000, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x800002, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x1398437, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xba98d27, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xba98d7a, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x751f853a, 0xff7fffe6, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x7f7ffff0, 0x0, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x7f7fffff, 0x75700000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x80000000, 0xff7ffff0, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x80000001, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x80000076, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x80002b94, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x80636d24, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x807fffff, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x80800000, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x80800002, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x81398437, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x8ba98d27, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x8ba98d7a, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xf51f853a, 0xff7ffff9, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xff7ffff0, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7ffff0, 0xff7fffff, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7ffff0, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x4f3495cb, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xe73a5134, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x7c994e9e, 0xff7b357b, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x6164bd6c, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x9503366, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xbf5a97c9, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xe6ff1a14, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x77f31e2f, 0xff7ffe09, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xaab4d7d8, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x966320b, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xb26bddee, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xb5c8e5d3, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x317285d3, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x3c9623b1, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x51fd2c7c, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x7b906a6c, 0xff7edf1b, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x0, 0xff7fffff, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x1, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x76, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x2b94, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x636d24, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x800000, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x800002, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x1398437, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xba98d27, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xba98d7a, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x751f853a, 0xff7ffff5, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x7f7ffff0, 0xf5700000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x7f7fffff, 0x0, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x80000000, 0xff7fffff, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x80000001, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x80000076, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x80002b94, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x80636d24, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x807fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x80800000, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x80800002, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x81398437, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x8ba98d27, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x8ba98d7a, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xf51f853a, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7fffff, 0xff7ffff0, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7fffff, 0xff7fffff, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7fffff, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x4f3495cb, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xe73a5134, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x7c994e9e, 0xff7b358a, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x6164bd6c, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x9503366, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xbf5a97c9, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xe6ff1a14, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x77f31e2f, 0xff7ffe18, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xaab4d7d8, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x966320b, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xb26bddee, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xb5c8e5d3, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x317285d3, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x3c9623b1, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x51fd2c7c, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x7b906a6c, 0xff7edf2a, 0x3c00010}, +{0x3c00000, 0xff800000, 0x0, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x1, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x76, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x2b94, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x636d24, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x7fffff, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x800002, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x1398437, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xba98d27, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xba98d7a, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x751f853a, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7f7ffff0, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7f7fffff, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x80000000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x80000001, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x80000076, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x80002b94, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x80636d24, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x807fffff, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x80800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x80800002, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x81398437, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x8ba98d27, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x8ba98d7a, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xf51f853a, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xff7ffff0, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xff7fffff, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x4f3495cb, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xe73a5134, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7c994e9e, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x6164bd6c, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x9503366, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xbf5a97c9, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xe6ff1a14, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x77f31e2f, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xaab4d7d8, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x966320b, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xb26bddee, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xb5c8e5d3, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x317285d3, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x3c9623b1, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x51fd2c7c, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7b906a6c, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800001, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x0, 0x4f3495cb, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x1, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x76, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x2b94, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x636d24, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x7fffff, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x800000, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x800002, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x1398437, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xba98d27, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xba98d7a, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x80000000, 0x4f3495cb, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x80000001, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x80000076, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x80002b94, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x80636d24, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x807fffff, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x80800000, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x80800002, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x81398437, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x8ba98d27, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x8ba98d7a, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x4f3495cb, 0x4fb495cb, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x9503366, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xbf5a97c9, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xaab4d7d8, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x966320b, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xb26bddee, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xb5c8e5d3, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x317285d3, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x3c9623b1, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x51fd2c7c, 0x52016895, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x0, 0xe73a5134, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x1, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x76, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x2b94, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x636d24, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x7fffff, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x800000, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x800002, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x1398437, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xba98d27, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xba98d7a, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x80000000, 0xe73a5134, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x80000001, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x80000076, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x80002b94, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x80636d24, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x807fffff, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x80800000, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x80800002, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x81398437, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x8ba98d27, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x8ba98d7a, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x4f3495cb, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xe73a5134, 0xe7ba5134, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x6164bd6c, 0xe73a42e8, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x9503366, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xbf5a97c9, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xe6ff1a14, 0xe79cef1f, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xaab4d7d8, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x966320b, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xb26bddee, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xb5c8e5d3, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x317285d3, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x3c9623b1, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x51fd2c7c, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x0, 0x7c994e9e, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x1, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x76, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x2b94, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x636d24, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x7fffff, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x800000, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x800002, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x1398437, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xba98d27, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xba98d7a, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x751f853a, 0x7c994fdd, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x7f7ffff0, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7c994e9e, 0x7f7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7c994e9e, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x80000000, 0x7c994e9e, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x80000001, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x80000076, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x80002b94, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x80636d24, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x807fffff, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x80800000, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x80800002, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x81398437, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x8ba98d27, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x8ba98d7a, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xf51f853a, 0x7c994d5e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xff7ffff0, 0xff7b357b, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xff7fffff, 0xff7b358a, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x4f3495cb, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xe73a5134, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x7c994e9e, 0x7d194e9e, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x6164bd6c, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x9503366, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xbf5a97c9, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xe6ff1a14, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x77f31e2f, 0x7c998b65, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xaab4d7d8, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x966320b, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xb26bddee, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xb5c8e5d3, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x317285d3, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x3c9623b1, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x51fd2c7c, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x7b906a6c, 0x7cbd6939, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x0, 0x6164bd6c, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x1, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x76, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x2b94, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x636d24, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x7fffff, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x800000, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x800002, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x1398437, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xba98d27, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xba98d7a, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x80000000, 0x6164bd6c, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x80000001, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x80000076, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x80002b94, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x80636d24, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x807fffff, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x80800000, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x80800002, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x81398437, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x8ba98d27, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x8ba98d7a, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x4f3495cb, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xe73a5134, 0xe73a42e8, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x6164bd6c, 0x61e4bd6c, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x9503366, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xbf5a97c9, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xe6ff1a14, 0xe6fefd7c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xaab4d7d8, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x966320b, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xb26bddee, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xb5c8e5d3, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x317285d3, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x3c9623b1, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x51fd2c7c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x9503366, 0x0, 0x9503366, 0x3c00000}, +{0x3c00000, 0x9503366, 0x1, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x76, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x2b94, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x636d24, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x7fffff, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x800000, 0x95033a6, 0x3c00000}, +{0x3c00000, 0x9503366, 0x800002, 0x95033a6, 0x3c00010}, +{0x3c00000, 0x9503366, 0x1398437, 0x950341f, 0x3c00010}, +{0x3c00000, 0x9503366, 0xba98d27, 0xbb00ec2, 0x3c00010}, +{0x3c00000, 0x9503366, 0xba98d7a, 0xbb00f15, 0x3c00010}, +{0x3c00000, 0x9503366, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x9503366, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x9503366, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x9503366, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x9503366, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0x80000000, 0x9503366, 0x3c00000}, +{0x3c00000, 0x9503366, 0x80000001, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x80000076, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x80002b94, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x80636d24, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x807fffff, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x80800000, 0x9503326, 0x3c00000}, +{0x3c00000, 0x9503366, 0x80800002, 0x9503325, 0x3c00010}, +{0x3c00000, 0x9503366, 0x81398437, 0x95032ac, 0x3c00010}, +{0x3c00000, 0x9503366, 0x8ba98d27, 0x8ba30b8b, 0x3c00010}, +{0x3c00000, 0x9503366, 0x8ba98d7a, 0x8ba30bde, 0x3c00010}, +{0x3c00000, 0x9503366, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x9503366, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x9503366, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x9503366, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x9503366, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0x4f3495cb, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x9503366, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0x9503366, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x9503366, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x9503366, 0x9503366, 0x9d03366, 0x3c00000}, +{0x3c00000, 0x9503366, 0xbf5a97c9, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0x9503366, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0x9503366, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x9503366, 0xaab4d7d8, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0x9503366, 0x966320b, 0x9db32b8, 0x3c00010}, +{0x3c00000, 0x9503366, 0xb26bddee, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0x9503366, 0xb5c8e5d3, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0x9503366, 0x317285d3, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x9503366, 0x3c9623b1, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x9503366, 0x51fd2c7c, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x9503366, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x0, 0xbf5a97c9, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x1, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x76, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x2b94, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x636d24, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x7fffff, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x800000, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x800002, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x1398437, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xba98d27, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xba98d7a, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x80000000, 0xbf5a97c9, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x80000001, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x80000076, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x80002b94, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x80636d24, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x807fffff, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x80800000, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x80800002, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x81398437, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x8ba98d27, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x8ba98d7a, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x4f3495cb, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xe73a5134, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x6164bd6c, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x9503366, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xbf5a97c9, 0xbfda97c9, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0xe6ff1a14, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xaab4d7d8, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x966320b, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xb26bddee, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xb5c8e5d3, 0xbf5a97e2, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x317285d3, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x3c9623b1, 0xbf55e6ab, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x51fd2c7c, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x0, 0xe6ff1a14, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x1, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x76, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x2b94, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x636d24, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x7fffff, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x800000, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x800002, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x1398437, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xba98d27, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xba98d7a, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x80000000, 0xe6ff1a14, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x80000001, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x80000076, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x80002b94, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x80636d24, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x807fffff, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x80800000, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x80800002, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x81398437, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x8ba98d27, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x8ba98d7a, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x4f3495cb, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xe73a5134, 0xe79cef1f, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x6164bd6c, 0xe6fefd7c, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x9503366, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xbf5a97c9, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xe6ff1a14, 0xe77f1a14, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xaab4d7d8, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x966320b, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xb26bddee, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xb5c8e5d3, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x317285d3, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x3c9623b1, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x51fd2c7c, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x0, 0x77f31e2f, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x1, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x76, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x2b94, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x636d24, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x7fffff, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x800000, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x800002, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x1398437, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xba98d27, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xba98d7a, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x751f853a, 0x77f81a58, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x7f7ffff0, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x77f31e2f, 0x7f7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x77f31e2f, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x80000000, 0x77f31e2f, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x80000001, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x80000076, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x80002b94, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x80636d24, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x807fffff, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x80800000, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x80800002, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x81398437, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x8ba98d27, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x8ba98d7a, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xf51f853a, 0x77ee2205, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xff7ffff0, 0xff7ffe09, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xff7fffff, 0xff7ffe18, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x4f3495cb, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xe73a5134, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x7c994e9e, 0x7c998b65, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x6164bd6c, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x9503366, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xbf5a97c9, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xe6ff1a14, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x77f31e2f, 0x78731e2f, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0xaab4d7d8, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x966320b, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xb26bddee, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xb5c8e5d3, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x317285d3, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x3c9623b1, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x51fd2c7c, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x7b906a6c, 0x7b915d8a, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x0, 0xaab4d7d8, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x1, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x76, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x2b94, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x636d24, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x7fffff, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x800000, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x800002, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x1398437, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xba98d27, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xba98d7a, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x80000000, 0xaab4d7d8, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x80000001, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x80000076, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x80002b94, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x80636d24, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x807fffff, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x80800000, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x80800002, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x81398437, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x8ba98d27, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x8ba98d7a, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x4f3495cb, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xe73a5134, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x6164bd6c, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x9503366, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xbf5a97c9, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xe6ff1a14, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xaab4d7d8, 0xab34d7d8, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x966320b, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xb26bddee, 0xb26bdf57, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xb5c8e5d3, 0xb5c8e5d5, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x317285d3, 0x3172802c, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x3c9623b1, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x51fd2c7c, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x966320b, 0x0, 0x966320b, 0x3c00000}, +{0x3c00000, 0x966320b, 0x1, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x76, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x2b94, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x636d24, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x7fffff, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x800000, 0x966324b, 0x3c00000}, +{0x3c00000, 0x966320b, 0x800002, 0x966324b, 0x3c00010}, +{0x3c00000, 0x966320b, 0x1398437, 0x96632c4, 0x3c00010}, +{0x3c00000, 0x966320b, 0xba98d27, 0xbb0beb7, 0x3c00010}, +{0x3c00000, 0x966320b, 0xba98d7a, 0xbb0bf0a, 0x3c00010}, +{0x3c00000, 0x966320b, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x966320b, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x966320b, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x966320b, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x966320b, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0x80000000, 0x966320b, 0x3c00000}, +{0x3c00000, 0x966320b, 0x80000001, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x80000076, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x80002b94, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x80636d24, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x807fffff, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x80800000, 0x96631cb, 0x3c00000}, +{0x3c00000, 0x966320b, 0x80800002, 0x96631ca, 0x3c00010}, +{0x3c00000, 0x966320b, 0x81398437, 0x9663151, 0x3c00010}, +{0x3c00000, 0x966320b, 0x8ba98d27, 0x8ba25b96, 0x3c00010}, +{0x3c00000, 0x966320b, 0x8ba98d7a, 0x8ba25be9, 0x3c00010}, +{0x3c00000, 0x966320b, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x966320b, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x966320b, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x966320b, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x966320b, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0x4f3495cb, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x966320b, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0x966320b, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x966320b, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x966320b, 0x9503366, 0x9db32b8, 0x3c00010}, +{0x3c00000, 0x966320b, 0xbf5a97c9, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0x966320b, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0x966320b, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x966320b, 0xaab4d7d8, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0x966320b, 0x966320b, 0x9e6320b, 0x3c00000}, +{0x3c00000, 0x966320b, 0xb26bddee, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0x966320b, 0xb5c8e5d3, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0x966320b, 0x317285d3, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x966320b, 0x3c9623b1, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x966320b, 0x51fd2c7c, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x966320b, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x0, 0xb26bddee, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x1, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x76, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x2b94, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x636d24, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x7fffff, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x800000, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x800002, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x1398437, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xba98d27, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xba98d7a, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x80000000, 0xb26bddee, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x80000001, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x80000076, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x80002b94, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x80636d24, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x807fffff, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x80800000, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x80800002, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x81398437, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x8ba98d27, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x8ba98d7a, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x4f3495cb, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xe73a5134, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x6164bd6c, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x9503366, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xbf5a97c9, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xe6ff1a14, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xaab4d7d8, 0xb26bdf57, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x966320b, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xb26bddee, 0xb2ebddee, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0xb5c8e5d3, 0xb5cabd8e, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x317285d3, 0xb22f3c79, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x3c9623b1, 0x3c9623a9, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x51fd2c7c, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x0, 0xb5c8e5d3, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x1, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x76, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x2b94, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x636d24, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x7fffff, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x800000, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x800002, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x1398437, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xba98d27, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xba98d7a, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x751f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x7f7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x7f7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x80000000, 0xb5c8e5d3, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x80000001, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x80000076, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x80002b94, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x80636d24, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x807fffff, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x80800000, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x80800002, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x81398437, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x8ba98d27, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x8ba98d7a, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xf51f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xff7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xff7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x4f3495cb, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xe73a5134, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x7c994e9e, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x6164bd6c, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x9503366, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xbf5a97c9, 0xbf5a97e2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xe6ff1a14, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x77f31e2f, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xaab4d7d8, 0xb5c8e5d5, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x966320b, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xb26bddee, 0xb5cabd8e, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xb5c8e5d3, 0xb648e5d3, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x317285d3, 0xb5c86c90, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x3c9623b1, 0x3c96208d, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x51fd2c7c, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x7b906a6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x0, 0x317285d3, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x1, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x76, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x2b94, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x636d24, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x7fffff, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x800000, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x800002, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x1398437, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xba98d27, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xba98d7a, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x80000000, 0x317285d3, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x80000001, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x80000076, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x80002b94, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x80636d24, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x807fffff, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x80800000, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x80800002, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x81398437, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x8ba98d27, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x8ba98d7a, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x4f3495cb, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x9503366, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xbf5a97c9, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xaab4d7d8, 0x3172802c, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x966320b, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xb26bddee, 0xb22f3c79, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xb5c8e5d3, 0xb5c86c90, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x317285d3, 0x31f285d3, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x3c9623b1, 0x3c9623b2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x51fd2c7c, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x0, 0x3c9623b1, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x76, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x2b94, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x636d24, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x7fffff, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x800000, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x800002, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x1398437, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xba98d27, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xba98d7a, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x80000000, 0x3c9623b1, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x80000001, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x80000076, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x80002b94, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x80636d24, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x807fffff, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x80800000, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x80800002, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x81398437, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x8ba98d27, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x8ba98d7a, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x4f3495cb, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x9503366, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xbf5a97c9, 0xbf55e6ab, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xaab4d7d8, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x966320b, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xb26bddee, 0x3c9623a9, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xb5c8e5d3, 0x3c96208d, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x317285d3, 0x3c9623b2, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x3c9623b1, 0x3d1623b1, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x51fd2c7c, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x0, 0x51fd2c7c, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x1, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x76, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x2b94, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x636d24, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x7fffff, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x800000, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x800002, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x1398437, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xba98d27, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xba98d7a, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x751f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x7f7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x7f7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x80000000, 0x51fd2c7c, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x80000001, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x80000076, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x80002b94, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x80636d24, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x807fffff, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x80800000, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x80800002, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x81398437, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x8ba98d27, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x8ba98d7a, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xf51f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xff7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xff7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x4f3495cb, 0x52016895, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xe73a5134, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x7c994e9e, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x6164bd6c, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x9503366, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xbf5a97c9, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xe6ff1a14, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x77f31e2f, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xaab4d7d8, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x966320b, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xb26bddee, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xb5c8e5d3, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x317285d3, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x3c9623b1, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x51fd2c7c, 0x527d2c7c, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x7b906a6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x0, 0x7b906a6c, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x1, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x76, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x2b94, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x636d24, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x7fffff, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x800000, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x800002, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x1398437, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xba98d27, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xba98d7a, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x751f853a, 0x7b906f68, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x7f7ffff0, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7b906a6c, 0x7f7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7b906a6c, 0x7f800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x80000000, 0x7b906a6c, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x80000001, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x80000076, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x80002b94, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x80636d24, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x807fffff, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x80800000, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x80800002, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x81398437, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x8ba98d27, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x8ba98d7a, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xf51f853a, 0x7b90656f, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xff7ffff0, 0xff7edf1b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xff7fffff, 0xff7edf2a, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xff800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x4f3495cb, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xe73a5134, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x7c994e9e, 0x7cbd6939, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x6164bd6c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x9503366, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xbf5a97c9, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xe6ff1a14, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x77f31e2f, 0x7b915d8a, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xaab4d7d8, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x966320b, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xb26bddee, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xb5c8e5d3, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x317285d3, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x3c9623b1, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x51fd2c7c, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x7b906a6c, 0x7c106a6c, 0x3c00000}, +{0x3800000, 0x0, 0x0, 0x0, 0x3800000}, +{0x3800000, 0x0, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x0, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x0, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x0, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x0, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x0, 0x800000, 0x800000, 0x3800000}, +{0x3800000, 0x0, 0x800002, 0x800002, 0x3800000}, +{0x3800000, 0x0, 0x1398437, 0x1398437, 0x3800000}, +{0x3800000, 0x0, 0xba98d27, 0xba98d27, 0x3800000}, +{0x3800000, 0x0, 0xba98d7a, 0xba98d7a, 0x3800000}, +{0x3800000, 0x0, 0x751f853a, 0x751f853a, 0x3800000}, +{0x3800000, 0x0, 0x7f7ffff0, 0x7f7ffff0, 0x3800000}, +{0x3800000, 0x0, 0x7f7fffff, 0x7f7fffff, 0x3800000}, +{0x3800000, 0x0, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x0, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0x80000000, 0x80000000, 0x3800000}, +{0x3800000, 0x0, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x0, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x0, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x0, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x0, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x0, 0x80800000, 0x80800000, 0x3800000}, +{0x3800000, 0x0, 0x80800002, 0x80800002, 0x3800000}, +{0x3800000, 0x0, 0x81398437, 0x81398437, 0x3800000}, +{0x3800000, 0x0, 0x8ba98d27, 0x8ba98d27, 0x3800000}, +{0x3800000, 0x0, 0x8ba98d7a, 0x8ba98d7a, 0x3800000}, +{0x3800000, 0x0, 0xf51f853a, 0xf51f853a, 0x3800000}, +{0x3800000, 0x0, 0xff7ffff0, 0xff7ffff0, 0x3800000}, +{0x3800000, 0x0, 0xff7fffff, 0xff7fffff, 0x3800000}, +{0x3800000, 0x0, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x0, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0x4f3495cb, 0x4f3495cb, 0x3800000}, +{0x3800000, 0x0, 0xe73a5134, 0xe73a5134, 0x3800000}, +{0x3800000, 0x0, 0x7c994e9e, 0x7c994e9e, 0x3800000}, +{0x3800000, 0x0, 0x6164bd6c, 0x6164bd6c, 0x3800000}, +{0x3800000, 0x0, 0x9503366, 0x9503366, 0x3800000}, +{0x3800000, 0x0, 0xbf5a97c9, 0xbf5a97c9, 0x3800000}, +{0x3800000, 0x0, 0xe6ff1a14, 0xe6ff1a14, 0x3800000}, +{0x3800000, 0x0, 0x77f31e2f, 0x77f31e2f, 0x3800000}, +{0x3800000, 0x0, 0xaab4d7d8, 0xaab4d7d8, 0x3800000}, +{0x3800000, 0x0, 0x966320b, 0x966320b, 0x3800000}, +{0x3800000, 0x0, 0xb26bddee, 0xb26bddee, 0x3800000}, +{0x3800000, 0x0, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800000}, +{0x3800000, 0x0, 0x317285d3, 0x317285d3, 0x3800000}, +{0x3800000, 0x0, 0x3c9623b1, 0x3c9623b1, 0x3800000}, +{0x3800000, 0x0, 0x51fd2c7c, 0x51fd2c7c, 0x3800000}, +{0x3800000, 0x0, 0x7b906a6c, 0x7b906a6c, 0x3800000}, +{0x3800000, 0x1, 0x0, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x800000, 0x800000, 0x3800080}, +{0x3800000, 0x1, 0x800002, 0x800002, 0x3800080}, +{0x3800000, 0x1, 0x1398437, 0x1398437, 0x3800080}, +{0x3800000, 0x1, 0xba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x1, 0xba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x1, 0x751f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x1, 0x7f7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x1, 0x7f7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x1, 0x7f800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x1, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0x80000000, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x80800000, 0x80800000, 0x3800080}, +{0x3800000, 0x1, 0x80800002, 0x80800002, 0x3800080}, +{0x3800000, 0x1, 0x81398437, 0x81398437, 0x3800080}, +{0x3800000, 0x1, 0x8ba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x1, 0x8ba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x1, 0xf51f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x1, 0xff7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x1, 0xff7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x1, 0xff800000, 0xff800000, 0x3800080}, +{0x3800000, 0x1, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0x4f3495cb, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x1, 0xe73a5134, 0xe73a5134, 0x3800080}, +{0x3800000, 0x1, 0x7c994e9e, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x1, 0x6164bd6c, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x1, 0x9503366, 0x9503366, 0x3800080}, +{0x3800000, 0x1, 0xbf5a97c9, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0x1, 0xe6ff1a14, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0x1, 0x77f31e2f, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x1, 0xaab4d7d8, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0x1, 0x966320b, 0x966320b, 0x3800080}, +{0x3800000, 0x1, 0xb26bddee, 0xb26bddee, 0x3800080}, +{0x3800000, 0x1, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0x1, 0x317285d3, 0x317285d3, 0x3800080}, +{0x3800000, 0x1, 0x3c9623b1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x1, 0x51fd2c7c, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x1, 0x7b906a6c, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x76, 0x0, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x800000, 0x800000, 0x3800080}, +{0x3800000, 0x76, 0x800002, 0x800002, 0x3800080}, +{0x3800000, 0x76, 0x1398437, 0x1398437, 0x3800080}, +{0x3800000, 0x76, 0xba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x76, 0xba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x76, 0x751f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x76, 0x7f7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x76, 0x7f7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x76, 0x7f800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x76, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0x80000000, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x80800000, 0x80800000, 0x3800080}, +{0x3800000, 0x76, 0x80800002, 0x80800002, 0x3800080}, +{0x3800000, 0x76, 0x81398437, 0x81398437, 0x3800080}, +{0x3800000, 0x76, 0x8ba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x76, 0x8ba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x76, 0xf51f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x76, 0xff7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x76, 0xff7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x76, 0xff800000, 0xff800000, 0x3800080}, +{0x3800000, 0x76, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0x4f3495cb, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x76, 0xe73a5134, 0xe73a5134, 0x3800080}, +{0x3800000, 0x76, 0x7c994e9e, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x76, 0x6164bd6c, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x76, 0x9503366, 0x9503366, 0x3800080}, +{0x3800000, 0x76, 0xbf5a97c9, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0x76, 0xe6ff1a14, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0x76, 0x77f31e2f, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x76, 0xaab4d7d8, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0x76, 0x966320b, 0x966320b, 0x3800080}, +{0x3800000, 0x76, 0xb26bddee, 0xb26bddee, 0x3800080}, +{0x3800000, 0x76, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0x76, 0x317285d3, 0x317285d3, 0x3800080}, +{0x3800000, 0x76, 0x3c9623b1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x76, 0x51fd2c7c, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x76, 0x7b906a6c, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x2b94, 0x0, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x800000, 0x800000, 0x3800080}, +{0x3800000, 0x2b94, 0x800002, 0x800002, 0x3800080}, +{0x3800000, 0x2b94, 0x1398437, 0x1398437, 0x3800080}, +{0x3800000, 0x2b94, 0xba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x2b94, 0xba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x2b94, 0x751f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x2b94, 0x7f7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x2b94, 0x7f7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x2b94, 0x7f800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x2b94, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0x80000000, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x80800000, 0x80800000, 0x3800080}, +{0x3800000, 0x2b94, 0x80800002, 0x80800002, 0x3800080}, +{0x3800000, 0x2b94, 0x81398437, 0x81398437, 0x3800080}, +{0x3800000, 0x2b94, 0x8ba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x2b94, 0x8ba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x2b94, 0xf51f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x2b94, 0xff7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x2b94, 0xff7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x2b94, 0xff800000, 0xff800000, 0x3800080}, +{0x3800000, 0x2b94, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0x4f3495cb, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x2b94, 0xe73a5134, 0xe73a5134, 0x3800080}, +{0x3800000, 0x2b94, 0x7c994e9e, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x2b94, 0x6164bd6c, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x2b94, 0x9503366, 0x9503366, 0x3800080}, +{0x3800000, 0x2b94, 0xbf5a97c9, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0x2b94, 0xe6ff1a14, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0x2b94, 0x77f31e2f, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x2b94, 0xaab4d7d8, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0x2b94, 0x966320b, 0x966320b, 0x3800080}, +{0x3800000, 0x2b94, 0xb26bddee, 0xb26bddee, 0x3800080}, +{0x3800000, 0x2b94, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0x2b94, 0x317285d3, 0x317285d3, 0x3800080}, +{0x3800000, 0x2b94, 0x3c9623b1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x2b94, 0x51fd2c7c, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x2b94, 0x7b906a6c, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x636d24, 0x0, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x800000, 0x800000, 0x3800080}, +{0x3800000, 0x636d24, 0x800002, 0x800002, 0x3800080}, +{0x3800000, 0x636d24, 0x1398437, 0x1398437, 0x3800080}, +{0x3800000, 0x636d24, 0xba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x636d24, 0xba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x636d24, 0x751f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x636d24, 0x7f7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x636d24, 0x7f7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x636d24, 0x7f800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x636d24, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0x80000000, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x80800000, 0x80800000, 0x3800080}, +{0x3800000, 0x636d24, 0x80800002, 0x80800002, 0x3800080}, +{0x3800000, 0x636d24, 0x81398437, 0x81398437, 0x3800080}, +{0x3800000, 0x636d24, 0x8ba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x636d24, 0x8ba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x636d24, 0xf51f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x636d24, 0xff7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x636d24, 0xff7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x636d24, 0xff800000, 0xff800000, 0x3800080}, +{0x3800000, 0x636d24, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0x4f3495cb, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x636d24, 0xe73a5134, 0xe73a5134, 0x3800080}, +{0x3800000, 0x636d24, 0x7c994e9e, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x636d24, 0x6164bd6c, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x636d24, 0x9503366, 0x9503366, 0x3800080}, +{0x3800000, 0x636d24, 0xbf5a97c9, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0x636d24, 0xe6ff1a14, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0x636d24, 0x77f31e2f, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x636d24, 0xaab4d7d8, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0x636d24, 0x966320b, 0x966320b, 0x3800080}, +{0x3800000, 0x636d24, 0xb26bddee, 0xb26bddee, 0x3800080}, +{0x3800000, 0x636d24, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0x636d24, 0x317285d3, 0x317285d3, 0x3800080}, +{0x3800000, 0x636d24, 0x3c9623b1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x636d24, 0x51fd2c7c, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x636d24, 0x7b906a6c, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7fffff, 0x0, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x800000, 0x800000, 0x3800080}, +{0x3800000, 0x7fffff, 0x800002, 0x800002, 0x3800080}, +{0x3800000, 0x7fffff, 0x1398437, 0x1398437, 0x3800080}, +{0x3800000, 0x7fffff, 0xba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x7fffff, 0xba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x7fffff, 0x751f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x7fffff, 0x7f7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7fffff, 0x7f7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7fffff, 0x7f800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x7fffff, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0x80000000, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x80800000, 0x80800000, 0x3800080}, +{0x3800000, 0x7fffff, 0x80800002, 0x80800002, 0x3800080}, +{0x3800000, 0x7fffff, 0x81398437, 0x81398437, 0x3800080}, +{0x3800000, 0x7fffff, 0x8ba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x7fffff, 0x8ba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x7fffff, 0xf51f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x7fffff, 0xff7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x7fffff, 0xff7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x7fffff, 0xff800000, 0xff800000, 0x3800080}, +{0x3800000, 0x7fffff, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0x4f3495cb, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x7fffff, 0xe73a5134, 0xe73a5134, 0x3800080}, +{0x3800000, 0x7fffff, 0x7c994e9e, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7fffff, 0x6164bd6c, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x7fffff, 0x9503366, 0x9503366, 0x3800080}, +{0x3800000, 0x7fffff, 0xbf5a97c9, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0x7fffff, 0xe6ff1a14, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0x7fffff, 0x77f31e2f, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x7fffff, 0xaab4d7d8, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0x7fffff, 0x966320b, 0x966320b, 0x3800080}, +{0x3800000, 0x7fffff, 0xb26bddee, 0xb26bddee, 0x3800080}, +{0x3800000, 0x7fffff, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0x7fffff, 0x317285d3, 0x317285d3, 0x3800080}, +{0x3800000, 0x7fffff, 0x3c9623b1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x7fffff, 0x51fd2c7c, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x7fffff, 0x7b906a6c, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x800000, 0x0, 0x800000, 0x3800000}, +{0x3800000, 0x800000, 0x1, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x76, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x2b94, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x636d24, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x7fffff, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x800000, 0x1000000, 0x3800000}, +{0x3800000, 0x800000, 0x800002, 0x1000001, 0x3800000}, +{0x3800000, 0x800000, 0x1398437, 0x1798437, 0x3800000}, +{0x3800000, 0x800000, 0xba98d27, 0xba98d29, 0x3800000}, +{0x3800000, 0x800000, 0xba98d7a, 0xba98d7c, 0x3800000}, +{0x3800000, 0x800000, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x800000, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x800000, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x800000, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x800000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0x80000000, 0x800000, 0x3800000}, +{0x3800000, 0x800000, 0x80000001, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x80000076, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x80002b94, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x80636d24, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x807fffff, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x80800000, 0x80000000, 0x3800000}, +{0x3800000, 0x800000, 0x80800002, 0x0, 0x3800008}, +{0x3800000, 0x800000, 0x81398437, 0x80f3086e, 0x3800000}, +{0x3800000, 0x800000, 0x8ba98d27, 0x8ba98d25, 0x3800000}, +{0x3800000, 0x800000, 0x8ba98d7a, 0x8ba98d78, 0x3800000}, +{0x3800000, 0x800000, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x800000, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x800000, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x800000, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x800000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0x4f3495cb, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x800000, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0x800000, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x800000, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x800000, 0x9503366, 0x95033a6, 0x3800000}, +{0x3800000, 0x800000, 0xbf5a97c9, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0x800000, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0x800000, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x800000, 0xaab4d7d8, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0x800000, 0x966320b, 0x966324b, 0x3800000}, +{0x3800000, 0x800000, 0xb26bddee, 0xb26bddee, 0x3800010}, +{0x3800000, 0x800000, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0x800000, 0x317285d3, 0x317285d3, 0x3800010}, +{0x3800000, 0x800000, 0x3c9623b1, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x800000, 0x51fd2c7c, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x800000, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x800002, 0x0, 0x800002, 0x3800000}, +{0x3800000, 0x800002, 0x1, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x76, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x2b94, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x636d24, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x7fffff, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x800000, 0x1000001, 0x3800000}, +{0x3800000, 0x800002, 0x800002, 0x1000002, 0x3800000}, +{0x3800000, 0x800002, 0x1398437, 0x1798438, 0x3800000}, +{0x3800000, 0x800002, 0xba98d27, 0xba98d29, 0x3800010}, +{0x3800000, 0x800002, 0xba98d7a, 0xba98d7c, 0x3800010}, +{0x3800000, 0x800002, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x800002, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x800002, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x800002, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x800002, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0x80000000, 0x800002, 0x3800000}, +{0x3800000, 0x800002, 0x80000001, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x80000076, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x80002b94, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x80636d24, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x807fffff, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x80800000, 0x0, 0x3800008}, +{0x3800000, 0x800002, 0x80800002, 0x80000000, 0x3800000}, +{0x3800000, 0x800002, 0x81398437, 0x80f3086c, 0x3800000}, +{0x3800000, 0x800002, 0x8ba98d27, 0x8ba98d25, 0x3800010}, +{0x3800000, 0x800002, 0x8ba98d7a, 0x8ba98d78, 0x3800010}, +{0x3800000, 0x800002, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x800002, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x800002, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x800002, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x800002, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0x4f3495cb, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x800002, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0x800002, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x800002, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x800002, 0x9503366, 0x95033a6, 0x3800010}, +{0x3800000, 0x800002, 0xbf5a97c9, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0x800002, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0x800002, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x800002, 0xaab4d7d8, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0x800002, 0x966320b, 0x966324b, 0x3800010}, +{0x3800000, 0x800002, 0xb26bddee, 0xb26bddee, 0x3800010}, +{0x3800000, 0x800002, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0x800002, 0x317285d3, 0x317285d3, 0x3800010}, +{0x3800000, 0x800002, 0x3c9623b1, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x800002, 0x51fd2c7c, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x800002, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x1398437, 0x0, 0x1398437, 0x3800000}, +{0x3800000, 0x1398437, 0x1, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x76, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x2b94, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x636d24, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x7fffff, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x800000, 0x1798437, 0x3800000}, +{0x3800000, 0x1398437, 0x800002, 0x1798438, 0x3800000}, +{0x3800000, 0x1398437, 0x1398437, 0x1b98437, 0x3800000}, +{0x3800000, 0x1398437, 0xba98d27, 0xba98d2c, 0x3800010}, +{0x3800000, 0x1398437, 0xba98d7a, 0xba98d7f, 0x3800010}, +{0x3800000, 0x1398437, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x1398437, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x1398437, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x1398437, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x1398437, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0x80000000, 0x1398437, 0x3800000}, +{0x3800000, 0x1398437, 0x80000001, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x80000076, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x80002b94, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x80636d24, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x807fffff, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x80800000, 0xf3086e, 0x3800000}, +{0x3800000, 0x1398437, 0x80800002, 0xf3086c, 0x3800000}, +{0x3800000, 0x1398437, 0x81398437, 0x80000000, 0x3800000}, +{0x3800000, 0x1398437, 0x8ba98d27, 0x8ba98d22, 0x3800010}, +{0x3800000, 0x1398437, 0x8ba98d7a, 0x8ba98d75, 0x3800010}, +{0x3800000, 0x1398437, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x1398437, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x1398437, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x1398437, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x1398437, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0x4f3495cb, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x1398437, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0x1398437, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x1398437, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x1398437, 0x9503366, 0x950341f, 0x3800010}, +{0x3800000, 0x1398437, 0xbf5a97c9, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0x1398437, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0x1398437, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x1398437, 0xaab4d7d8, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0x1398437, 0x966320b, 0x96632c4, 0x3800010}, +{0x3800000, 0x1398437, 0xb26bddee, 0xb26bddee, 0x3800010}, +{0x3800000, 0x1398437, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0x1398437, 0x317285d3, 0x317285d3, 0x3800010}, +{0x3800000, 0x1398437, 0x3c9623b1, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x1398437, 0x51fd2c7c, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x1398437, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0xba98d27, 0x0, 0xba98d27, 0x3800000}, +{0x3800000, 0xba98d27, 0x1, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x76, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x2b94, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x636d24, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x7fffff, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x800000, 0xba98d29, 0x3800000}, +{0x3800000, 0xba98d27, 0x800002, 0xba98d29, 0x3800010}, +{0x3800000, 0xba98d27, 0x1398437, 0xba98d2c, 0x3800010}, +{0x3800000, 0xba98d27, 0xba98d27, 0xc298d27, 0x3800000}, +{0x3800000, 0xba98d27, 0xba98d7a, 0xc298d50, 0x3800010}, +{0x3800000, 0xba98d27, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0xba98d27, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0xba98d27, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0xba98d27, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xba98d27, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0x80000000, 0xba98d27, 0x3800000}, +{0x3800000, 0xba98d27, 0x80000001, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x80000076, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x80002b94, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x80636d24, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x807fffff, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x80800000, 0xba98d25, 0x3800000}, +{0x3800000, 0xba98d27, 0x80800002, 0xba98d24, 0x3800010}, +{0x3800000, 0xba98d27, 0x81398437, 0xba98d21, 0x3800010}, +{0x3800000, 0xba98d27, 0x8ba98d27, 0x80000000, 0x3800000}, +{0x3800000, 0xba98d27, 0x8ba98d7a, 0x83260000, 0x3800000}, +{0x3800000, 0xba98d27, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0xba98d27, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xba98d27, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0xba98d27, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xba98d27, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0x4f3495cb, 0x4f3495cb, 0x3800010}, +{0x3800000, 0xba98d27, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0xba98d27, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0xba98d27, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0xba98d27, 0x9503366, 0xbb00ec2, 0x3800010}, +{0x3800000, 0xba98d27, 0xbf5a97c9, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xba98d27, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xba98d27, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0xba98d27, 0xaab4d7d8, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xba98d27, 0x966320b, 0xbb0beb7, 0x3800010}, +{0x3800000, 0xba98d27, 0xb26bddee, 0xb26bddee, 0x3800010}, +{0x3800000, 0xba98d27, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xba98d27, 0x317285d3, 0x317285d3, 0x3800010}, +{0x3800000, 0xba98d27, 0x3c9623b1, 0x3c9623b1, 0x3800010}, +{0x3800000, 0xba98d27, 0x51fd2c7c, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0xba98d27, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0xba98d7a, 0x0, 0xba98d7a, 0x3800000}, +{0x3800000, 0xba98d7a, 0x1, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x76, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x2b94, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x636d24, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x7fffff, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x800000, 0xba98d7c, 0x3800000}, +{0x3800000, 0xba98d7a, 0x800002, 0xba98d7c, 0x3800010}, +{0x3800000, 0xba98d7a, 0x1398437, 0xba98d7f, 0x3800010}, +{0x3800000, 0xba98d7a, 0xba98d27, 0xc298d50, 0x3800010}, +{0x3800000, 0xba98d7a, 0xba98d7a, 0xc298d7a, 0x3800000}, +{0x3800000, 0xba98d7a, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0xba98d7a, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0xba98d7a, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0xba98d7a, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x80000000, 0xba98d7a, 0x3800000}, +{0x3800000, 0xba98d7a, 0x80000001, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x80000076, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x80002b94, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x80636d24, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x807fffff, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x80800000, 0xba98d78, 0x3800000}, +{0x3800000, 0xba98d7a, 0x80800002, 0xba98d77, 0x3800010}, +{0x3800000, 0xba98d7a, 0x81398437, 0xba98d74, 0x3800010}, +{0x3800000, 0xba98d7a, 0x8ba98d27, 0x3260000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x8ba98d7a, 0x80000000, 0x3800000}, +{0x3800000, 0xba98d7a, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0xba98d7a, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xba98d7a, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0xba98d7a, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xba98d7a, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x4f3495cb, 0x4f3495cb, 0x3800010}, +{0x3800000, 0xba98d7a, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0xba98d7a, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0xba98d7a, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0xba98d7a, 0x9503366, 0xbb00f15, 0x3800010}, +{0x3800000, 0xba98d7a, 0xbf5a97c9, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xba98d7a, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xba98d7a, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0xba98d7a, 0xaab4d7d8, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xba98d7a, 0x966320b, 0xbb0bf0a, 0x3800010}, +{0x3800000, 0xba98d7a, 0xb26bddee, 0xb26bddee, 0x3800010}, +{0x3800000, 0xba98d7a, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xba98d7a, 0x317285d3, 0x317285d3, 0x3800010}, +{0x3800000, 0xba98d7a, 0x3c9623b1, 0x3c9623b1, 0x3800010}, +{0x3800000, 0xba98d7a, 0x51fd2c7c, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0xba98d7a, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x751f853a, 0x0, 0x751f853a, 0x3800000}, +{0x3800000, 0x751f853a, 0x1, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x76, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x2b94, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x636d24, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x7fffff, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x800000, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x800002, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x1398437, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0xba98d27, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0xba98d7a, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x751f853a, 0x759f853a, 0x3800000}, +{0x3800000, 0x751f853a, 0x7f7ffff0, 0x7f7ffff9, 0x3800010}, +{0x3800000, 0x751f853a, 0x7f7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x751f853a, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x751f853a, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0x80000000, 0x751f853a, 0x3800000}, +{0x3800000, 0x751f853a, 0x80000001, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x80000076, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x80002b94, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x80636d24, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x807fffff, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x80800000, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x80800002, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x81398437, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x8ba98d27, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x8ba98d7a, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0xf51f853a, 0x80000000, 0x3800000}, +{0x3800000, 0x751f853a, 0xff7ffff0, 0xff7fffe7, 0x3800010}, +{0x3800000, 0x751f853a, 0xff7fffff, 0xff7ffff6, 0x3800010}, +{0x3800000, 0x751f853a, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x751f853a, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0x4f3495cb, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0xe73a5134, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x7c994e9e, 0x7c994fdd, 0x3800010}, +{0x3800000, 0x751f853a, 0x6164bd6c, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x9503366, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0xbf5a97c9, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0xe6ff1a14, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x77f31e2f, 0x77f81a58, 0x3800010}, +{0x3800000, 0x751f853a, 0xaab4d7d8, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x966320b, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0xb26bddee, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0xb5c8e5d3, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x317285d3, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x3c9623b1, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x51fd2c7c, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x7b906a6c, 0x7b906f68, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x0, 0x7f7ffff0, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x1, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x76, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x2b94, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x636d24, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x7fffff, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x800000, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x800002, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x1398437, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xba98d27, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xba98d7a, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x751f853a, 0x7f7ffff9, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x7f7ffff0, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7ffff0, 0x7f7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7ffff0, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x80000000, 0x7f7ffff0, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x80000001, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x80000076, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x80002b94, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x80636d24, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x807fffff, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x80800000, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x80800002, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x81398437, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x8ba98d27, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x8ba98d7a, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xf51f853a, 0x7f7fffe6, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xff7ffff0, 0x80000000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0xff7fffff, 0xf5700000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x4f3495cb, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xe73a5134, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x7c994e9e, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7ffff0, 0x6164bd6c, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x9503366, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xbf5a97c9, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xe6ff1a14, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x77f31e2f, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7ffff0, 0xaab4d7d8, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x966320b, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xb26bddee, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xb5c8e5d3, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x317285d3, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x3c9623b1, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x51fd2c7c, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x7b906a6c, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7fffff, 0x0, 0x7f7fffff, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x1, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x76, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x2b94, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x636d24, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x800000, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x800002, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x1398437, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xba98d27, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xba98d7a, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x751f853a, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7fffff, 0x7f7ffff0, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7fffff, 0x7f7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7fffff, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x80000000, 0x7f7fffff, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x80000001, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x80000076, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x80002b94, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x80636d24, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x807fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x80800000, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x80800002, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x81398437, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x8ba98d27, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x8ba98d7a, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xf51f853a, 0x7f7ffff5, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xff7ffff0, 0x75700000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0xff7fffff, 0x80000000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x4f3495cb, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xe73a5134, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x7c994e9e, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7fffff, 0x6164bd6c, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x9503366, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xbf5a97c9, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xe6ff1a14, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x77f31e2f, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7fffff, 0xaab4d7d8, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x966320b, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xb26bddee, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xb5c8e5d3, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x317285d3, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x3c9623b1, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x51fd2c7c, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x7b906a6c, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f800000, 0x0, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x1, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x76, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x2b94, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x636d24, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x7fffff, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x800002, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x1398437, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xba98d27, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xba98d7a, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x751f853a, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7f7ffff0, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7f7fffff, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0x80000000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x80000001, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x80000076, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x80002b94, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x80636d24, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x807fffff, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x80800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x80800002, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x81398437, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x8ba98d27, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x8ba98d7a, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xf51f853a, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xff7ffff0, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xff7fffff, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0x4f3495cb, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xe73a5134, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7c994e9e, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x6164bd6c, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x9503366, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xbf5a97c9, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xe6ff1a14, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x77f31e2f, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xaab4d7d8, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x966320b, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xb26bddee, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xb5c8e5d3, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x317285d3, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x3c9623b1, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x51fd2c7c, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7b906a6c, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800001, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0x0, 0x80000000, 0x3800000}, +{0x3800000, 0x80000000, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x800000, 0x800000, 0x3800000}, +{0x3800000, 0x80000000, 0x800002, 0x800002, 0x3800000}, +{0x3800000, 0x80000000, 0x1398437, 0x1398437, 0x3800000}, +{0x3800000, 0x80000000, 0xba98d27, 0xba98d27, 0x3800000}, +{0x3800000, 0x80000000, 0xba98d7a, 0xba98d7a, 0x3800000}, +{0x3800000, 0x80000000, 0x751f853a, 0x751f853a, 0x3800000}, +{0x3800000, 0x80000000, 0x7f7ffff0, 0x7f7ffff0, 0x3800000}, +{0x3800000, 0x80000000, 0x7f7fffff, 0x7f7fffff, 0x3800000}, +{0x3800000, 0x80000000, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x80000000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0x80000000, 0x80000000, 0x3800000}, +{0x3800000, 0x80000000, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x80800000, 0x80800000, 0x3800000}, +{0x3800000, 0x80000000, 0x80800002, 0x80800002, 0x3800000}, +{0x3800000, 0x80000000, 0x81398437, 0x81398437, 0x3800000}, +{0x3800000, 0x80000000, 0x8ba98d27, 0x8ba98d27, 0x3800000}, +{0x3800000, 0x80000000, 0x8ba98d7a, 0x8ba98d7a, 0x3800000}, +{0x3800000, 0x80000000, 0xf51f853a, 0xf51f853a, 0x3800000}, +{0x3800000, 0x80000000, 0xff7ffff0, 0xff7ffff0, 0x3800000}, +{0x3800000, 0x80000000, 0xff7fffff, 0xff7fffff, 0x3800000}, +{0x3800000, 0x80000000, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x80000000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0x4f3495cb, 0x4f3495cb, 0x3800000}, +{0x3800000, 0x80000000, 0xe73a5134, 0xe73a5134, 0x3800000}, +{0x3800000, 0x80000000, 0x7c994e9e, 0x7c994e9e, 0x3800000}, +{0x3800000, 0x80000000, 0x6164bd6c, 0x6164bd6c, 0x3800000}, +{0x3800000, 0x80000000, 0x9503366, 0x9503366, 0x3800000}, +{0x3800000, 0x80000000, 0xbf5a97c9, 0xbf5a97c9, 0x3800000}, +{0x3800000, 0x80000000, 0xe6ff1a14, 0xe6ff1a14, 0x3800000}, +{0x3800000, 0x80000000, 0x77f31e2f, 0x77f31e2f, 0x3800000}, +{0x3800000, 0x80000000, 0xaab4d7d8, 0xaab4d7d8, 0x3800000}, +{0x3800000, 0x80000000, 0x966320b, 0x966320b, 0x3800000}, +{0x3800000, 0x80000000, 0xb26bddee, 0xb26bddee, 0x3800000}, +{0x3800000, 0x80000000, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800000}, +{0x3800000, 0x80000000, 0x317285d3, 0x317285d3, 0x3800000}, +{0x3800000, 0x80000000, 0x3c9623b1, 0x3c9623b1, 0x3800000}, +{0x3800000, 0x80000000, 0x51fd2c7c, 0x51fd2c7c, 0x3800000}, +{0x3800000, 0x80000000, 0x7b906a6c, 0x7b906a6c, 0x3800000}, +{0x3800000, 0x80000001, 0x0, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x800000, 0x800000, 0x3800080}, +{0x3800000, 0x80000001, 0x800002, 0x800002, 0x3800080}, +{0x3800000, 0x80000001, 0x1398437, 0x1398437, 0x3800080}, +{0x3800000, 0x80000001, 0xba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x80000001, 0xba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x80000001, 0x751f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x80000001, 0x7f7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x80000001, 0x7f7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x80000001, 0x7f800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x80000001, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0x80000000, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x80800000, 0x80800000, 0x3800080}, +{0x3800000, 0x80000001, 0x80800002, 0x80800002, 0x3800080}, +{0x3800000, 0x80000001, 0x81398437, 0x81398437, 0x3800080}, +{0x3800000, 0x80000001, 0x8ba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x80000001, 0x8ba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x80000001, 0xf51f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x80000001, 0xff7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x80000001, 0xff7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x80000001, 0xff800000, 0xff800000, 0x3800080}, +{0x3800000, 0x80000001, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0x4f3495cb, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x80000001, 0xe73a5134, 0xe73a5134, 0x3800080}, +{0x3800000, 0x80000001, 0x7c994e9e, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x80000001, 0x6164bd6c, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x80000001, 0x9503366, 0x9503366, 0x3800080}, +{0x3800000, 0x80000001, 0xbf5a97c9, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0x80000001, 0xe6ff1a14, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0x80000001, 0x77f31e2f, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x80000001, 0xaab4d7d8, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0x80000001, 0x966320b, 0x966320b, 0x3800080}, +{0x3800000, 0x80000001, 0xb26bddee, 0xb26bddee, 0x3800080}, +{0x3800000, 0x80000001, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0x80000001, 0x317285d3, 0x317285d3, 0x3800080}, +{0x3800000, 0x80000001, 0x3c9623b1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x80000001, 0x51fd2c7c, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x80000001, 0x7b906a6c, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x80000076, 0x0, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x800000, 0x800000, 0x3800080}, +{0x3800000, 0x80000076, 0x800002, 0x800002, 0x3800080}, +{0x3800000, 0x80000076, 0x1398437, 0x1398437, 0x3800080}, +{0x3800000, 0x80000076, 0xba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x80000076, 0xba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x80000076, 0x751f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x80000076, 0x7f7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x80000076, 0x7f7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x80000076, 0x7f800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x80000076, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0x80000000, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x80800000, 0x80800000, 0x3800080}, +{0x3800000, 0x80000076, 0x80800002, 0x80800002, 0x3800080}, +{0x3800000, 0x80000076, 0x81398437, 0x81398437, 0x3800080}, +{0x3800000, 0x80000076, 0x8ba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x80000076, 0x8ba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x80000076, 0xf51f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x80000076, 0xff7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x80000076, 0xff7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x80000076, 0xff800000, 0xff800000, 0x3800080}, +{0x3800000, 0x80000076, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0x4f3495cb, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x80000076, 0xe73a5134, 0xe73a5134, 0x3800080}, +{0x3800000, 0x80000076, 0x7c994e9e, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x80000076, 0x6164bd6c, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x80000076, 0x9503366, 0x9503366, 0x3800080}, +{0x3800000, 0x80000076, 0xbf5a97c9, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0x80000076, 0xe6ff1a14, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0x80000076, 0x77f31e2f, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x80000076, 0xaab4d7d8, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0x80000076, 0x966320b, 0x966320b, 0x3800080}, +{0x3800000, 0x80000076, 0xb26bddee, 0xb26bddee, 0x3800080}, +{0x3800000, 0x80000076, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0x80000076, 0x317285d3, 0x317285d3, 0x3800080}, +{0x3800000, 0x80000076, 0x3c9623b1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x80000076, 0x51fd2c7c, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x80000076, 0x7b906a6c, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x80002b94, 0x0, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x800000, 0x800000, 0x3800080}, +{0x3800000, 0x80002b94, 0x800002, 0x800002, 0x3800080}, +{0x3800000, 0x80002b94, 0x1398437, 0x1398437, 0x3800080}, +{0x3800000, 0x80002b94, 0xba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x80002b94, 0xba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x80002b94, 0x751f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x80002b94, 0x7f7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x80002b94, 0x7f7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x80002b94, 0x7f800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x80002b94, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0x80000000, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x80800000, 0x80800000, 0x3800080}, +{0x3800000, 0x80002b94, 0x80800002, 0x80800002, 0x3800080}, +{0x3800000, 0x80002b94, 0x81398437, 0x81398437, 0x3800080}, +{0x3800000, 0x80002b94, 0x8ba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x80002b94, 0x8ba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x80002b94, 0xf51f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x80002b94, 0xff7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x80002b94, 0xff7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x80002b94, 0xff800000, 0xff800000, 0x3800080}, +{0x3800000, 0x80002b94, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0x4f3495cb, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x80002b94, 0xe73a5134, 0xe73a5134, 0x3800080}, +{0x3800000, 0x80002b94, 0x7c994e9e, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x80002b94, 0x6164bd6c, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x80002b94, 0x9503366, 0x9503366, 0x3800080}, +{0x3800000, 0x80002b94, 0xbf5a97c9, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0x80002b94, 0xe6ff1a14, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0x80002b94, 0x77f31e2f, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x80002b94, 0xaab4d7d8, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0x80002b94, 0x966320b, 0x966320b, 0x3800080}, +{0x3800000, 0x80002b94, 0xb26bddee, 0xb26bddee, 0x3800080}, +{0x3800000, 0x80002b94, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0x80002b94, 0x317285d3, 0x317285d3, 0x3800080}, +{0x3800000, 0x80002b94, 0x3c9623b1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x80002b94, 0x51fd2c7c, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x80002b94, 0x7b906a6c, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x80636d24, 0x0, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x800000, 0x800000, 0x3800080}, +{0x3800000, 0x80636d24, 0x800002, 0x800002, 0x3800080}, +{0x3800000, 0x80636d24, 0x1398437, 0x1398437, 0x3800080}, +{0x3800000, 0x80636d24, 0xba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x80636d24, 0xba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x80636d24, 0x751f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x80636d24, 0x7f7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x80636d24, 0x7f7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x80636d24, 0x7f800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x80636d24, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0x80000000, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x80800000, 0x80800000, 0x3800080}, +{0x3800000, 0x80636d24, 0x80800002, 0x80800002, 0x3800080}, +{0x3800000, 0x80636d24, 0x81398437, 0x81398437, 0x3800080}, +{0x3800000, 0x80636d24, 0x8ba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x80636d24, 0x8ba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x80636d24, 0xf51f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x80636d24, 0xff7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x80636d24, 0xff7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x80636d24, 0xff800000, 0xff800000, 0x3800080}, +{0x3800000, 0x80636d24, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0x4f3495cb, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x80636d24, 0xe73a5134, 0xe73a5134, 0x3800080}, +{0x3800000, 0x80636d24, 0x7c994e9e, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x80636d24, 0x6164bd6c, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x80636d24, 0x9503366, 0x9503366, 0x3800080}, +{0x3800000, 0x80636d24, 0xbf5a97c9, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0x80636d24, 0xe6ff1a14, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0x80636d24, 0x77f31e2f, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x80636d24, 0xaab4d7d8, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0x80636d24, 0x966320b, 0x966320b, 0x3800080}, +{0x3800000, 0x80636d24, 0xb26bddee, 0xb26bddee, 0x3800080}, +{0x3800000, 0x80636d24, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0x80636d24, 0x317285d3, 0x317285d3, 0x3800080}, +{0x3800000, 0x80636d24, 0x3c9623b1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x80636d24, 0x51fd2c7c, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x80636d24, 0x7b906a6c, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x807fffff, 0x0, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x1, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x76, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x2b94, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x636d24, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x7fffff, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x800000, 0x800000, 0x3800080}, +{0x3800000, 0x807fffff, 0x800002, 0x800002, 0x3800080}, +{0x3800000, 0x807fffff, 0x1398437, 0x1398437, 0x3800080}, +{0x3800000, 0x807fffff, 0xba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x807fffff, 0xba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x807fffff, 0x751f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x807fffff, 0x7f7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x807fffff, 0x7f7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x807fffff, 0x7f800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x807fffff, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0x80000000, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x80000001, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x80000076, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x80002b94, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x80636d24, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x807fffff, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x80800000, 0x80800000, 0x3800080}, +{0x3800000, 0x807fffff, 0x80800002, 0x80800002, 0x3800080}, +{0x3800000, 0x807fffff, 0x81398437, 0x81398437, 0x3800080}, +{0x3800000, 0x807fffff, 0x8ba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x807fffff, 0x8ba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x807fffff, 0xf51f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x807fffff, 0xff7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x807fffff, 0xff7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x807fffff, 0xff800000, 0xff800000, 0x3800080}, +{0x3800000, 0x807fffff, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0x4f3495cb, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x807fffff, 0xe73a5134, 0xe73a5134, 0x3800080}, +{0x3800000, 0x807fffff, 0x7c994e9e, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x807fffff, 0x6164bd6c, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x807fffff, 0x9503366, 0x9503366, 0x3800080}, +{0x3800000, 0x807fffff, 0xbf5a97c9, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0x807fffff, 0xe6ff1a14, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0x807fffff, 0x77f31e2f, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x807fffff, 0xaab4d7d8, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0x807fffff, 0x966320b, 0x966320b, 0x3800080}, +{0x3800000, 0x807fffff, 0xb26bddee, 0xb26bddee, 0x3800080}, +{0x3800000, 0x807fffff, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0x807fffff, 0x317285d3, 0x317285d3, 0x3800080}, +{0x3800000, 0x807fffff, 0x3c9623b1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x807fffff, 0x51fd2c7c, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x807fffff, 0x7b906a6c, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x80800000, 0x0, 0x80800000, 0x3800000}, +{0x3800000, 0x80800000, 0x1, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x76, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x2b94, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x636d24, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x7fffff, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x800000, 0x80000000, 0x3800000}, +{0x3800000, 0x80800000, 0x800002, 0x0, 0x3800008}, +{0x3800000, 0x80800000, 0x1398437, 0xf3086e, 0x3800000}, +{0x3800000, 0x80800000, 0xba98d27, 0xba98d25, 0x3800000}, +{0x3800000, 0x80800000, 0xba98d7a, 0xba98d78, 0x3800000}, +{0x3800000, 0x80800000, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0x80800000, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x80800000, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x80800000, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x80800000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0x80000000, 0x80800000, 0x3800000}, +{0x3800000, 0x80800000, 0x80000001, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x80000076, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x80002b94, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x80636d24, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x807fffff, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x80800000, 0x81000000, 0x3800000}, +{0x3800000, 0x80800000, 0x80800002, 0x81000001, 0x3800000}, +{0x3800000, 0x80800000, 0x81398437, 0x81798437, 0x3800000}, +{0x3800000, 0x80800000, 0x8ba98d27, 0x8ba98d29, 0x3800000}, +{0x3800000, 0x80800000, 0x8ba98d7a, 0x8ba98d7c, 0x3800000}, +{0x3800000, 0x80800000, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0x80800000, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0x80800000, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0x80800000, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x80800000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0x4f3495cb, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x80800000, 0xe73a5134, 0xe73a5135, 0x3800010}, +{0x3800000, 0x80800000, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x80800000, 0x6164bd6c, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x80800000, 0x9503366, 0x9503326, 0x3800000}, +{0x3800000, 0x80800000, 0xbf5a97c9, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0x80800000, 0xe6ff1a14, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0x80800000, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x80800000, 0xaab4d7d8, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0x80800000, 0x966320b, 0x96631cb, 0x3800000}, +{0x3800000, 0x80800000, 0xb26bddee, 0xb26bddef, 0x3800010}, +{0x3800000, 0x80800000, 0xb5c8e5d3, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0x80800000, 0x317285d3, 0x317285d2, 0x3800010}, +{0x3800000, 0x80800000, 0x3c9623b1, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x80800000, 0x51fd2c7c, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x80800000, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x80800002, 0x0, 0x80800002, 0x3800000}, +{0x3800000, 0x80800002, 0x1, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x76, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x2b94, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x636d24, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x7fffff, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x800000, 0x0, 0x3800008}, +{0x3800000, 0x80800002, 0x800002, 0x80000000, 0x3800000}, +{0x3800000, 0x80800002, 0x1398437, 0xf3086c, 0x3800000}, +{0x3800000, 0x80800002, 0xba98d27, 0xba98d24, 0x3800010}, +{0x3800000, 0x80800002, 0xba98d7a, 0xba98d77, 0x3800010}, +{0x3800000, 0x80800002, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0x80800002, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x80800002, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x80800002, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x80800002, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0x80000000, 0x80800002, 0x3800000}, +{0x3800000, 0x80800002, 0x80000001, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x80000076, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x80002b94, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x80636d24, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x807fffff, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x80800000, 0x81000001, 0x3800000}, +{0x3800000, 0x80800002, 0x80800002, 0x81000002, 0x3800000}, +{0x3800000, 0x80800002, 0x81398437, 0x81798438, 0x3800000}, +{0x3800000, 0x80800002, 0x8ba98d27, 0x8ba98d2a, 0x3800010}, +{0x3800000, 0x80800002, 0x8ba98d7a, 0x8ba98d7d, 0x3800010}, +{0x3800000, 0x80800002, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0x80800002, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0x80800002, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0x80800002, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x80800002, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0x4f3495cb, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x80800002, 0xe73a5134, 0xe73a5135, 0x3800010}, +{0x3800000, 0x80800002, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x80800002, 0x6164bd6c, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x80800002, 0x9503366, 0x9503325, 0x3800010}, +{0x3800000, 0x80800002, 0xbf5a97c9, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0x80800002, 0xe6ff1a14, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0x80800002, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x80800002, 0xaab4d7d8, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0x80800002, 0x966320b, 0x96631ca, 0x3800010}, +{0x3800000, 0x80800002, 0xb26bddee, 0xb26bddef, 0x3800010}, +{0x3800000, 0x80800002, 0xb5c8e5d3, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0x80800002, 0x317285d3, 0x317285d2, 0x3800010}, +{0x3800000, 0x80800002, 0x3c9623b1, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x80800002, 0x51fd2c7c, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x80800002, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x81398437, 0x0, 0x81398437, 0x3800000}, +{0x3800000, 0x81398437, 0x1, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x76, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x2b94, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x636d24, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x7fffff, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x800000, 0x80f3086e, 0x3800000}, +{0x3800000, 0x81398437, 0x800002, 0x80f3086c, 0x3800000}, +{0x3800000, 0x81398437, 0x1398437, 0x80000000, 0x3800000}, +{0x3800000, 0x81398437, 0xba98d27, 0xba98d21, 0x3800010}, +{0x3800000, 0x81398437, 0xba98d7a, 0xba98d74, 0x3800010}, +{0x3800000, 0x81398437, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0x81398437, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x81398437, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x81398437, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x81398437, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0x80000000, 0x81398437, 0x3800000}, +{0x3800000, 0x81398437, 0x80000001, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x80000076, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x80002b94, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x80636d24, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x807fffff, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x80800000, 0x81798437, 0x3800000}, +{0x3800000, 0x81398437, 0x80800002, 0x81798438, 0x3800000}, +{0x3800000, 0x81398437, 0x81398437, 0x81b98437, 0x3800000}, +{0x3800000, 0x81398437, 0x8ba98d27, 0x8ba98d2d, 0x3800010}, +{0x3800000, 0x81398437, 0x8ba98d7a, 0x8ba98d80, 0x3800010}, +{0x3800000, 0x81398437, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0x81398437, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0x81398437, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0x81398437, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x81398437, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0x4f3495cb, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x81398437, 0xe73a5134, 0xe73a5135, 0x3800010}, +{0x3800000, 0x81398437, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x81398437, 0x6164bd6c, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x81398437, 0x9503366, 0x95032ac, 0x3800010}, +{0x3800000, 0x81398437, 0xbf5a97c9, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0x81398437, 0xe6ff1a14, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0x81398437, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x81398437, 0xaab4d7d8, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0x81398437, 0x966320b, 0x9663151, 0x3800010}, +{0x3800000, 0x81398437, 0xb26bddee, 0xb26bddef, 0x3800010}, +{0x3800000, 0x81398437, 0xb5c8e5d3, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0x81398437, 0x317285d3, 0x317285d2, 0x3800010}, +{0x3800000, 0x81398437, 0x3c9623b1, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x81398437, 0x51fd2c7c, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x81398437, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x0, 0x8ba98d27, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x1, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x76, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x2b94, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x636d24, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x7fffff, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x800000, 0x8ba98d25, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x800002, 0x8ba98d25, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x1398437, 0x8ba98d22, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xba98d27, 0x80000000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0xba98d7a, 0x3260000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x80000000, 0x8ba98d27, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x80000001, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x80000076, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x80002b94, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x80636d24, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x807fffff, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x80800000, 0x8ba98d29, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x80800002, 0x8ba98d2a, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x81398437, 0x8ba98d2d, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x8ba98d27, 0x8c298d27, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x8ba98d7a, 0x8c298d51, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0x8ba98d27, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x4f3495cb, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xe73a5134, 0xe73a5135, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x6164bd6c, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x9503366, 0x8ba30b8c, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xbf5a97c9, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xe6ff1a14, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xaab4d7d8, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x966320b, 0x8ba25b97, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xb26bddee, 0xb26bddef, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xb5c8e5d3, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x317285d3, 0x317285d2, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x3c9623b1, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x51fd2c7c, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x0, 0x8ba98d7a, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x1, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x76, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x2b94, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x636d24, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x7fffff, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x800000, 0x8ba98d78, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x800002, 0x8ba98d78, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x1398437, 0x8ba98d75, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xba98d27, 0x83260000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0xba98d7a, 0x80000000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x80000000, 0x8ba98d7a, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x80000001, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x80000076, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x80002b94, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x80636d24, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x807fffff, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x80800000, 0x8ba98d7c, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x80800002, 0x8ba98d7d, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x81398437, 0x8ba98d80, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x8ba98d27, 0x8c298d51, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x8ba98d7a, 0x8c298d7a, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0x8ba98d7a, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x4f3495cb, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xe73a5134, 0xe73a5135, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x6164bd6c, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x9503366, 0x8ba30bdf, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xbf5a97c9, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xe6ff1a14, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xaab4d7d8, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x966320b, 0x8ba25bea, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xb26bddee, 0xb26bddef, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xb5c8e5d3, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x317285d3, 0x317285d2, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x3c9623b1, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x51fd2c7c, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x0, 0xf51f853a, 0x3800000}, +{0x3800000, 0xf51f853a, 0x1, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x76, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x2b94, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x636d24, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x7fffff, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x800000, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x800002, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x1398437, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0xba98d27, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0xba98d7a, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x751f853a, 0x80000000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x7f7ffff0, 0x7f7fffe6, 0x3800010}, +{0x3800000, 0xf51f853a, 0x7f7fffff, 0x7f7ffff5, 0x3800010}, +{0x3800000, 0xf51f853a, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x80000000, 0xf51f853a, 0x3800000}, +{0x3800000, 0xf51f853a, 0x80000001, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x80000076, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x80002b94, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x80636d24, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x807fffff, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x80800000, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x80800002, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x81398437, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x8ba98d27, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x8ba98d7a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0xf51f853a, 0xf59f853a, 0x3800000}, +{0x3800000, 0xf51f853a, 0xff7ffff0, 0xff7ffffa, 0x3800010}, +{0x3800000, 0xf51f853a, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xf51f853a, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xf51f853a, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x4f3495cb, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0xe73a5134, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x7c994e9e, 0x7c994d5e, 0x3800010}, +{0x3800000, 0xf51f853a, 0x6164bd6c, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x9503366, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0xbf5a97c9, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0xe6ff1a14, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x77f31e2f, 0x77ee2205, 0x3800010}, +{0x3800000, 0xf51f853a, 0xaab4d7d8, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x966320b, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0xb26bddee, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0xb5c8e5d3, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x317285d3, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x3c9623b1, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x51fd2c7c, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x7b906a6c, 0x7b90656f, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x0, 0xff7ffff0, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x1, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x76, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x2b94, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x636d24, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x7fffff, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x800000, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x800002, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x1398437, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xba98d27, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xba98d7a, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x751f853a, 0xff7fffe7, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x7f7ffff0, 0x80000000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x7f7fffff, 0x75700000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x80000000, 0xff7ffff0, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x80000001, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x80000076, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x80002b94, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x80636d24, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x807fffff, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x80800000, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x80800002, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x81398437, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x8ba98d27, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x8ba98d7a, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xf51f853a, 0xff7ffffa, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xff7ffff0, 0xff800000, 0x3800014}, +{0x3800000, 0xff7ffff0, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xff7ffff0, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x4f3495cb, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xe73a5134, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x7c994e9e, 0xff7b357c, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x6164bd6c, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x9503366, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xbf5a97c9, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xe6ff1a14, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x77f31e2f, 0xff7ffe0a, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xaab4d7d8, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x966320b, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xb26bddee, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xb5c8e5d3, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x317285d3, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x3c9623b1, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x51fd2c7c, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x7b906a6c, 0xff7edf1c, 0x3800010}, +{0x3800000, 0xff7fffff, 0x0, 0xff7fffff, 0x3800000}, +{0x3800000, 0xff7fffff, 0x1, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x76, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x2b94, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x636d24, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x800000, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x800002, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x1398437, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0xba98d27, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0xba98d7a, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x751f853a, 0xff7ffff6, 0x3800010}, +{0x3800000, 0xff7fffff, 0x7f7ffff0, 0xf5700000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x7f7fffff, 0x80000000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x80000000, 0xff7fffff, 0x3800000}, +{0x3800000, 0xff7fffff, 0x80000001, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x80000076, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x80002b94, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x80636d24, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x807fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x80800000, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x80800002, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x81398437, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x8ba98d27, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x8ba98d7a, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xf51f853a, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xff7ffff0, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xff7fffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x4f3495cb, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0xe73a5134, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x7c994e9e, 0xff7b358b, 0x3800010}, +{0x3800000, 0xff7fffff, 0x6164bd6c, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x9503366, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0xbf5a97c9, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xe6ff1a14, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x77f31e2f, 0xff7ffe19, 0x3800010}, +{0x3800000, 0xff7fffff, 0xaab4d7d8, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x966320b, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0xb26bddee, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xb5c8e5d3, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x317285d3, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x3c9623b1, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x51fd2c7c, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x7b906a6c, 0xff7edf2b, 0x3800010}, +{0x3800000, 0xff800000, 0x0, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x1, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x76, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x2b94, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x636d24, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x7fffff, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x800000, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x800002, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x1398437, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xba98d27, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xba98d7a, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x751f853a, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7f7ffff0, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7f7fffff, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0x80000000, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x80000001, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x80000076, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x80002b94, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x80636d24, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x807fffff, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x80800000, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x80800002, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x81398437, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x8ba98d27, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x8ba98d7a, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xf51f853a, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xff7ffff0, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xff7fffff, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0x4f3495cb, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xe73a5134, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7c994e9e, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x6164bd6c, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x9503366, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xbf5a97c9, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xe6ff1a14, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x77f31e2f, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xaab4d7d8, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x966320b, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xb26bddee, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xb5c8e5d3, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x317285d3, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x3c9623b1, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x51fd2c7c, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7b906a6c, 0xff800000, 0x3800000}, +{0x3800000, 0xff800001, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x0, 0x4f3495cb, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x1, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x76, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x2b94, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x636d24, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x7fffff, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x800000, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x800002, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x1398437, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xba98d27, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xba98d7a, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x80000000, 0x4f3495cb, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x80000001, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x80000076, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x80002b94, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x80636d24, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x807fffff, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x80800000, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x80800002, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x81398437, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x8ba98d27, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x8ba98d7a, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x4f3495cb, 0x4fb495cb, 0x3800000}, +{0x3800000, 0x4f3495cb, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x9503366, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xbf5a97c9, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xaab4d7d8, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x966320b, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xb26bddee, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xb5c8e5d3, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x317285d3, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x3c9623b1, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x51fd2c7c, 0x52016895, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0xe73a5134, 0x0, 0xe73a5134, 0x3800000}, +{0x3800000, 0xe73a5134, 0x1, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x76, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x2b94, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x636d24, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x7fffff, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x800000, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x800002, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x1398437, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0xba98d27, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0xba98d7a, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xe73a5134, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xe73a5134, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xe73a5134, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x80000000, 0xe73a5134, 0x3800000}, +{0x3800000, 0xe73a5134, 0x80000001, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x80000076, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x80002b94, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x80636d24, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x807fffff, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x80800000, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x80800002, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x81398437, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x8ba98d27, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x8ba98d7a, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xe73a5134, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xe73a5134, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xe73a5134, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xe73a5134, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x4f3495cb, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0xe73a5134, 0xe7ba5134, 0x3800000}, +{0x3800000, 0xe73a5134, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0xe73a5134, 0x6164bd6c, 0xe73a42e9, 0x3800010}, +{0x3800000, 0xe73a5134, 0x9503366, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0xbf5a97c9, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0xe6ff1a14, 0xe79cef1f, 0x3800000}, +{0x3800000, 0xe73a5134, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0xe73a5134, 0xaab4d7d8, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x966320b, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0xb26bddee, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0xb5c8e5d3, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x317285d3, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x3c9623b1, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x51fd2c7c, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x0, 0x7c994e9e, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x1, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x76, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x2b94, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x636d24, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x7fffff, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x800000, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x800002, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x1398437, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xba98d27, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xba98d7a, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x751f853a, 0x7c994fdd, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x7f7ffff0, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7c994e9e, 0x7f7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7c994e9e, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x80000000, 0x7c994e9e, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x80000001, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x80000076, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x80002b94, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x80636d24, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x807fffff, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x80800000, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x80800002, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x81398437, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x8ba98d27, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x8ba98d7a, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xf51f853a, 0x7c994d5e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xff7ffff0, 0xff7b357c, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xff7fffff, 0xff7b358b, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x4f3495cb, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xe73a5134, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x7c994e9e, 0x7d194e9e, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x6164bd6c, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x9503366, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xbf5a97c9, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xe6ff1a14, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x77f31e2f, 0x7c998b65, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xaab4d7d8, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x966320b, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xb26bddee, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xb5c8e5d3, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x317285d3, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x3c9623b1, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x51fd2c7c, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x7b906a6c, 0x7cbd6939, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x0, 0x6164bd6c, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x1, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x76, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x2b94, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x636d24, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x7fffff, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x800000, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x800002, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x1398437, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xba98d27, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xba98d7a, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x80000000, 0x6164bd6c, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x80000001, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x80000076, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x80002b94, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x80636d24, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x807fffff, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x80800000, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x80800002, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x81398437, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x8ba98d27, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x8ba98d7a, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x4f3495cb, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xe73a5134, 0xe73a42e9, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x6164bd6c, 0x61e4bd6c, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x9503366, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xbf5a97c9, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xe6ff1a14, 0xe6fefd7d, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xaab4d7d8, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x966320b, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xb26bddee, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xb5c8e5d3, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x317285d3, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x3c9623b1, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x51fd2c7c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x9503366, 0x0, 0x9503366, 0x3800000}, +{0x3800000, 0x9503366, 0x1, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x76, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x2b94, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x636d24, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x7fffff, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x800000, 0x95033a6, 0x3800000}, +{0x3800000, 0x9503366, 0x800002, 0x95033a6, 0x3800010}, +{0x3800000, 0x9503366, 0x1398437, 0x950341f, 0x3800010}, +{0x3800000, 0x9503366, 0xba98d27, 0xbb00ec2, 0x3800010}, +{0x3800000, 0x9503366, 0xba98d7a, 0xbb00f15, 0x3800010}, +{0x3800000, 0x9503366, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x9503366, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x9503366, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x9503366, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x9503366, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0x80000000, 0x9503366, 0x3800000}, +{0x3800000, 0x9503366, 0x80000001, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x80000076, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x80002b94, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x80636d24, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x807fffff, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x80800000, 0x9503326, 0x3800000}, +{0x3800000, 0x9503366, 0x80800002, 0x9503325, 0x3800010}, +{0x3800000, 0x9503366, 0x81398437, 0x95032ac, 0x3800010}, +{0x3800000, 0x9503366, 0x8ba98d27, 0x8ba30b8c, 0x3800010}, +{0x3800000, 0x9503366, 0x8ba98d7a, 0x8ba30bdf, 0x3800010}, +{0x3800000, 0x9503366, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x9503366, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x9503366, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x9503366, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x9503366, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0x4f3495cb, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x9503366, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0x9503366, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x9503366, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x9503366, 0x9503366, 0x9d03366, 0x3800000}, +{0x3800000, 0x9503366, 0xbf5a97c9, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0x9503366, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0x9503366, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x9503366, 0xaab4d7d8, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0x9503366, 0x966320b, 0x9db32b8, 0x3800010}, +{0x3800000, 0x9503366, 0xb26bddee, 0xb26bddee, 0x3800010}, +{0x3800000, 0x9503366, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0x9503366, 0x317285d3, 0x317285d3, 0x3800010}, +{0x3800000, 0x9503366, 0x3c9623b1, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x9503366, 0x51fd2c7c, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x9503366, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x0, 0xbf5a97c9, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x1, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x76, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x2b94, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x636d24, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x7fffff, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x800000, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x800002, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x1398437, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xba98d27, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xba98d7a, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x80000000, 0xbf5a97c9, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x80000001, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x80000076, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x80002b94, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x80636d24, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x807fffff, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x80800000, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x80800002, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x81398437, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x8ba98d27, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x8ba98d7a, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xbf5a97c9, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x4f3495cb, 0x4f3495ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xe73a5134, 0xe73a5135, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x6164bd6c, 0x6164bd6b, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x9503366, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xbf5a97c9, 0xbfda97c9, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0xe6ff1a14, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xaab4d7d8, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x966320b, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xb26bddee, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xb5c8e5d3, 0xbf5a97e3, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x317285d3, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x3c9623b1, 0xbf55e6ac, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x51fd2c7c, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x0, 0xe6ff1a14, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x1, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x76, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x2b94, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x636d24, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x7fffff, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x800000, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x800002, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x1398437, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xba98d27, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xba98d7a, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x80000000, 0xe6ff1a14, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x80000001, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x80000076, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x80002b94, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x80636d24, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x807fffff, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x80800000, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x80800002, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x81398437, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x8ba98d27, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x8ba98d7a, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xe6ff1a14, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x4f3495cb, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xe73a5134, 0xe79cef1f, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x6164bd6c, 0xe6fefd7d, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x9503366, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xbf5a97c9, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xe6ff1a14, 0xe77f1a14, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xaab4d7d8, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x966320b, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xb26bddee, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xb5c8e5d3, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x317285d3, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x3c9623b1, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x51fd2c7c, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x0, 0x77f31e2f, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x1, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x76, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x2b94, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x636d24, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x7fffff, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x800000, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x800002, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x1398437, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xba98d27, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xba98d7a, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x751f853a, 0x77f81a58, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x7f7ffff0, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x77f31e2f, 0x7f7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x77f31e2f, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x80000000, 0x77f31e2f, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x80000001, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x80000076, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x80002b94, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x80636d24, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x807fffff, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x80800000, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x80800002, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x81398437, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x8ba98d27, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x8ba98d7a, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xf51f853a, 0x77ee2205, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xff7ffff0, 0xff7ffe0a, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xff7fffff, 0xff7ffe19, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x4f3495cb, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xe73a5134, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x7c994e9e, 0x7c998b65, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x6164bd6c, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x9503366, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xbf5a97c9, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xe6ff1a14, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x77f31e2f, 0x78731e2f, 0x3800000}, +{0x3800000, 0x77f31e2f, 0xaab4d7d8, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x966320b, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xb26bddee, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xb5c8e5d3, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x317285d3, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x3c9623b1, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x51fd2c7c, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x7b906a6c, 0x7b915d8a, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x0, 0xaab4d7d8, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x1, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x76, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x2b94, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x636d24, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x7fffff, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x800000, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x800002, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x1398437, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xba98d27, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xba98d7a, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x80000000, 0xaab4d7d8, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x80000001, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x80000076, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x80002b94, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x80636d24, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x807fffff, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x80800000, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x80800002, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x81398437, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x8ba98d27, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x8ba98d7a, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xaab4d7d8, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x4f3495cb, 0x4f3495ca, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xe73a5134, 0xe73a5135, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x6164bd6c, 0x6164bd6b, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x9503366, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xbf5a97c9, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xe6ff1a14, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xaab4d7d8, 0xab34d7d8, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x966320b, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xb26bddee, 0xb26bdf58, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xb5c8e5d3, 0xb5c8e5d6, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x317285d3, 0x3172802c, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x3c9623b1, 0x3c9623b0, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x51fd2c7c, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x966320b, 0x0, 0x966320b, 0x3800000}, +{0x3800000, 0x966320b, 0x1, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x76, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x2b94, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x636d24, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x7fffff, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x800000, 0x966324b, 0x3800000}, +{0x3800000, 0x966320b, 0x800002, 0x966324b, 0x3800010}, +{0x3800000, 0x966320b, 0x1398437, 0x96632c4, 0x3800010}, +{0x3800000, 0x966320b, 0xba98d27, 0xbb0beb7, 0x3800010}, +{0x3800000, 0x966320b, 0xba98d7a, 0xbb0bf0a, 0x3800010}, +{0x3800000, 0x966320b, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x966320b, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x966320b, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x966320b, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x966320b, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0x80000000, 0x966320b, 0x3800000}, +{0x3800000, 0x966320b, 0x80000001, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x80000076, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x80002b94, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x80636d24, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x807fffff, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x80800000, 0x96631cb, 0x3800000}, +{0x3800000, 0x966320b, 0x80800002, 0x96631ca, 0x3800010}, +{0x3800000, 0x966320b, 0x81398437, 0x9663151, 0x3800010}, +{0x3800000, 0x966320b, 0x8ba98d27, 0x8ba25b97, 0x3800010}, +{0x3800000, 0x966320b, 0x8ba98d7a, 0x8ba25bea, 0x3800010}, +{0x3800000, 0x966320b, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x966320b, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x966320b, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x966320b, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x966320b, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0x4f3495cb, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x966320b, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0x966320b, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x966320b, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x966320b, 0x9503366, 0x9db32b8, 0x3800010}, +{0x3800000, 0x966320b, 0xbf5a97c9, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0x966320b, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0x966320b, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x966320b, 0xaab4d7d8, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0x966320b, 0x966320b, 0x9e6320b, 0x3800000}, +{0x3800000, 0x966320b, 0xb26bddee, 0xb26bddee, 0x3800010}, +{0x3800000, 0x966320b, 0xb5c8e5d3, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0x966320b, 0x317285d3, 0x317285d3, 0x3800010}, +{0x3800000, 0x966320b, 0x3c9623b1, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x966320b, 0x51fd2c7c, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x966320b, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0xb26bddee, 0x0, 0xb26bddee, 0x3800000}, +{0x3800000, 0xb26bddee, 0x1, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x76, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x2b94, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x636d24, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x7fffff, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x800000, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0x800002, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0x1398437, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0xba98d27, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0xba98d7a, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xb26bddee, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xb26bddee, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xb26bddee, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xb26bddee, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0x80000000, 0xb26bddee, 0x3800000}, +{0x3800000, 0xb26bddee, 0x80000001, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x80000076, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x80002b94, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x80636d24, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x807fffff, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x80800000, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0x80800002, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0x81398437, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0x8ba98d27, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0x8ba98d7a, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xb26bddee, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xb26bddee, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xb26bddee, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xb26bddee, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0x4f3495cb, 0x4f3495ca, 0x3800010}, +{0x3800000, 0xb26bddee, 0xe73a5134, 0xe73a5135, 0x3800010}, +{0x3800000, 0xb26bddee, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0xb26bddee, 0x6164bd6c, 0x6164bd6b, 0x3800010}, +{0x3800000, 0xb26bddee, 0x9503366, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0xbf5a97c9, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xb26bddee, 0xe6ff1a14, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xb26bddee, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0xb26bddee, 0xaab4d7d8, 0xb26bdf58, 0x3800010}, +{0x3800000, 0xb26bddee, 0x966320b, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0xb26bddee, 0xb2ebddee, 0x3800000}, +{0x3800000, 0xb26bddee, 0xb5c8e5d3, 0xb5cabd8f, 0x3800010}, +{0x3800000, 0xb26bddee, 0x317285d3, 0xb22f3c7a, 0x3800010}, +{0x3800000, 0xb26bddee, 0x3c9623b1, 0x3c9623a9, 0x3800010}, +{0x3800000, 0xb26bddee, 0x51fd2c7c, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0xb26bddee, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x0, 0xb5c8e5d3, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x1, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x76, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x2b94, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x636d24, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x7fffff, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x800000, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x800002, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x1398437, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xba98d27, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xba98d7a, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x751f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x7f7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x7f7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x80000000, 0xb5c8e5d3, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x80000001, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x80000076, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x80002b94, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x80636d24, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x807fffff, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x80800000, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x80800002, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x81398437, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x8ba98d27, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x8ba98d7a, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xf51f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xff7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xff7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xb5c8e5d3, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x4f3495cb, 0x4f3495ca, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xe73a5134, 0xe73a5135, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x7c994e9e, 0x7c994e9d, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x6164bd6c, 0x6164bd6b, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x9503366, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xbf5a97c9, 0xbf5a97e3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xe6ff1a14, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x77f31e2f, 0x77f31e2e, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xaab4d7d8, 0xb5c8e5d6, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x966320b, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xb26bddee, 0xb5cabd8f, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xb5c8e5d3, 0xb648e5d3, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x317285d3, 0xb5c86c91, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x3c9623b1, 0x3c96208d, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x51fd2c7c, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x7b906a6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x317285d3, 0x0, 0x317285d3, 0x3800000}, +{0x3800000, 0x317285d3, 0x1, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x76, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x2b94, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x636d24, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x7fffff, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x800000, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0x800002, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0x1398437, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0xba98d27, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0xba98d7a, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x317285d3, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x317285d3, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x317285d3, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x317285d3, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0x80000000, 0x317285d3, 0x3800000}, +{0x3800000, 0x317285d3, 0x80000001, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x80000076, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x80002b94, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x80636d24, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x807fffff, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x80800000, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0x80800002, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0x81398437, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0x8ba98d27, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0x8ba98d7a, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x317285d3, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x317285d3, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x317285d3, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x317285d3, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0x4f3495cb, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x317285d3, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0x317285d3, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x317285d3, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x317285d3, 0x9503366, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0xbf5a97c9, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0x317285d3, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0x317285d3, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x317285d3, 0xaab4d7d8, 0x3172802c, 0x3800010}, +{0x3800000, 0x317285d3, 0x966320b, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0xb26bddee, 0xb22f3c7a, 0x3800010}, +{0x3800000, 0x317285d3, 0xb5c8e5d3, 0xb5c86c91, 0x3800010}, +{0x3800000, 0x317285d3, 0x317285d3, 0x31f285d3, 0x3800000}, +{0x3800000, 0x317285d3, 0x3c9623b1, 0x3c9623b2, 0x3800010}, +{0x3800000, 0x317285d3, 0x51fd2c7c, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x317285d3, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x0, 0x3c9623b1, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x76, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x2b94, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x636d24, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x7fffff, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x800000, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x800002, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x1398437, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xba98d27, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xba98d7a, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x80000000, 0x3c9623b1, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x80000001, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x80000076, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x80002b94, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x80636d24, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x807fffff, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x80800000, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x80800002, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x81398437, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x8ba98d27, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x8ba98d7a, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x4f3495cb, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x9503366, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xbf5a97c9, 0xbf55e6ac, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xaab4d7d8, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x966320b, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xb26bddee, 0x3c9623a9, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xb5c8e5d3, 0x3c96208d, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x317285d3, 0x3c9623b2, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x3c9623b1, 0x3d1623b1, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x51fd2c7c, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x0, 0x51fd2c7c, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x1, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x76, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x2b94, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x636d24, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x7fffff, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x800000, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x800002, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x1398437, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xba98d27, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xba98d7a, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x751f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x7f7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x7f7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x80000000, 0x51fd2c7c, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x80000001, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x80000076, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x80002b94, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x80636d24, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x807fffff, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x80800000, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x80800002, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x81398437, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x8ba98d27, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x8ba98d7a, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xf51f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xff7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xff7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x4f3495cb, 0x52016895, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xe73a5134, 0xe73a5134, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x7c994e9e, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x6164bd6c, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x9503366, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xbf5a97c9, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xe6ff1a14, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x77f31e2f, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xaab4d7d8, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x966320b, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xb26bddee, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xb5c8e5d3, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x317285d3, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x3c9623b1, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x51fd2c7c, 0x527d2c7c, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x7b906a6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x0, 0x7b906a6c, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x1, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x76, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x2b94, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x636d24, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x7fffff, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x800000, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x800002, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x1398437, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xba98d27, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xba98d7a, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x751f853a, 0x7b906f68, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x7f7ffff0, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7b906a6c, 0x7f7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7b906a6c, 0x7f800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x80000000, 0x7b906a6c, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x80000001, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x80000076, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x80002b94, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x80636d24, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x807fffff, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x80800000, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x80800002, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x81398437, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x8ba98d27, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x8ba98d7a, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xf51f853a, 0x7b90656f, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xff7ffff0, 0xff7edf1c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xff7fffff, 0xff7edf2b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xff800000, 0xff800000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x4f3495cb, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xe73a5134, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x7c994e9e, 0x7cbd6939, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x6164bd6c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x9503366, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xbf5a97c9, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xe6ff1a14, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x77f31e2f, 0x7b915d8a, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xaab4d7d8, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x966320b, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xb26bddee, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xb5c8e5d3, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x317285d3, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x3c9623b1, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x51fd2c7c, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x7b906a6c, 0x7c106a6c, 0x3800000}, +{0x3400000, 0x0, 0x0, 0x0, 0x3400000}, +{0x3400000, 0x0, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x800000, 0x800000, 0x3400000}, +{0x3400000, 0x0, 0x800002, 0x800002, 0x3400000}, +{0x3400000, 0x0, 0x1398437, 0x1398437, 0x3400000}, +{0x3400000, 0x0, 0xba98d27, 0xba98d27, 0x3400000}, +{0x3400000, 0x0, 0xba98d7a, 0xba98d7a, 0x3400000}, +{0x3400000, 0x0, 0x751f853a, 0x751f853a, 0x3400000}, +{0x3400000, 0x0, 0x7f7ffff0, 0x7f7ffff0, 0x3400000}, +{0x3400000, 0x0, 0x7f7fffff, 0x7f7fffff, 0x3400000}, +{0x3400000, 0x0, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x0, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0x80000000, 0x0, 0x3400000}, +{0x3400000, 0x0, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x80800000, 0x80800000, 0x3400000}, +{0x3400000, 0x0, 0x80800002, 0x80800002, 0x3400000}, +{0x3400000, 0x0, 0x81398437, 0x81398437, 0x3400000}, +{0x3400000, 0x0, 0x8ba98d27, 0x8ba98d27, 0x3400000}, +{0x3400000, 0x0, 0x8ba98d7a, 0x8ba98d7a, 0x3400000}, +{0x3400000, 0x0, 0xf51f853a, 0xf51f853a, 0x3400000}, +{0x3400000, 0x0, 0xff7ffff0, 0xff7ffff0, 0x3400000}, +{0x3400000, 0x0, 0xff7fffff, 0xff7fffff, 0x3400000}, +{0x3400000, 0x0, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x0, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0x4f3495cb, 0x4f3495cb, 0x3400000}, +{0x3400000, 0x0, 0xe73a5134, 0xe73a5134, 0x3400000}, +{0x3400000, 0x0, 0x7c994e9e, 0x7c994e9e, 0x3400000}, +{0x3400000, 0x0, 0x6164bd6c, 0x6164bd6c, 0x3400000}, +{0x3400000, 0x0, 0x9503366, 0x9503366, 0x3400000}, +{0x3400000, 0x0, 0xbf5a97c9, 0xbf5a97c9, 0x3400000}, +{0x3400000, 0x0, 0xe6ff1a14, 0xe6ff1a14, 0x3400000}, +{0x3400000, 0x0, 0x77f31e2f, 0x77f31e2f, 0x3400000}, +{0x3400000, 0x0, 0xaab4d7d8, 0xaab4d7d8, 0x3400000}, +{0x3400000, 0x0, 0x966320b, 0x966320b, 0x3400000}, +{0x3400000, 0x0, 0xb26bddee, 0xb26bddee, 0x3400000}, +{0x3400000, 0x0, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400000}, +{0x3400000, 0x0, 0x317285d3, 0x317285d3, 0x3400000}, +{0x3400000, 0x0, 0x3c9623b1, 0x3c9623b1, 0x3400000}, +{0x3400000, 0x0, 0x51fd2c7c, 0x51fd2c7c, 0x3400000}, +{0x3400000, 0x0, 0x7b906a6c, 0x7b906a6c, 0x3400000}, +{0x3400000, 0x1, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x800000, 0x800000, 0x3400080}, +{0x3400000, 0x1, 0x800002, 0x800002, 0x3400080}, +{0x3400000, 0x1, 0x1398437, 0x1398437, 0x3400080}, +{0x3400000, 0x1, 0xba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x1, 0xba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x1, 0x751f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x1, 0x7f7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x1, 0x7f7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x1, 0x7f800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x1, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x80800000, 0x80800000, 0x3400080}, +{0x3400000, 0x1, 0x80800002, 0x80800002, 0x3400080}, +{0x3400000, 0x1, 0x81398437, 0x81398437, 0x3400080}, +{0x3400000, 0x1, 0x8ba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x1, 0x8ba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x1, 0xf51f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x1, 0xff7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x1, 0xff7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x1, 0xff800000, 0xff800000, 0x3400080}, +{0x3400000, 0x1, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0x4f3495cb, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x1, 0xe73a5134, 0xe73a5134, 0x3400080}, +{0x3400000, 0x1, 0x7c994e9e, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x1, 0x6164bd6c, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x1, 0x9503366, 0x9503366, 0x3400080}, +{0x3400000, 0x1, 0xbf5a97c9, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0x1, 0xe6ff1a14, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0x1, 0x77f31e2f, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x1, 0xaab4d7d8, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0x1, 0x966320b, 0x966320b, 0x3400080}, +{0x3400000, 0x1, 0xb26bddee, 0xb26bddee, 0x3400080}, +{0x3400000, 0x1, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0x1, 0x317285d3, 0x317285d3, 0x3400080}, +{0x3400000, 0x1, 0x3c9623b1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x1, 0x51fd2c7c, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x1, 0x7b906a6c, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x76, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x800000, 0x800000, 0x3400080}, +{0x3400000, 0x76, 0x800002, 0x800002, 0x3400080}, +{0x3400000, 0x76, 0x1398437, 0x1398437, 0x3400080}, +{0x3400000, 0x76, 0xba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x76, 0xba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x76, 0x751f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x76, 0x7f7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x76, 0x7f7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x76, 0x7f800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x76, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x80800000, 0x80800000, 0x3400080}, +{0x3400000, 0x76, 0x80800002, 0x80800002, 0x3400080}, +{0x3400000, 0x76, 0x81398437, 0x81398437, 0x3400080}, +{0x3400000, 0x76, 0x8ba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x76, 0x8ba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x76, 0xf51f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x76, 0xff7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x76, 0xff7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x76, 0xff800000, 0xff800000, 0x3400080}, +{0x3400000, 0x76, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0x4f3495cb, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x76, 0xe73a5134, 0xe73a5134, 0x3400080}, +{0x3400000, 0x76, 0x7c994e9e, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x76, 0x6164bd6c, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x76, 0x9503366, 0x9503366, 0x3400080}, +{0x3400000, 0x76, 0xbf5a97c9, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0x76, 0xe6ff1a14, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0x76, 0x77f31e2f, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x76, 0xaab4d7d8, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0x76, 0x966320b, 0x966320b, 0x3400080}, +{0x3400000, 0x76, 0xb26bddee, 0xb26bddee, 0x3400080}, +{0x3400000, 0x76, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0x76, 0x317285d3, 0x317285d3, 0x3400080}, +{0x3400000, 0x76, 0x3c9623b1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x76, 0x51fd2c7c, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x76, 0x7b906a6c, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x2b94, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x800000, 0x800000, 0x3400080}, +{0x3400000, 0x2b94, 0x800002, 0x800002, 0x3400080}, +{0x3400000, 0x2b94, 0x1398437, 0x1398437, 0x3400080}, +{0x3400000, 0x2b94, 0xba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x2b94, 0xba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x2b94, 0x751f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x2b94, 0x7f7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x2b94, 0x7f7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x2b94, 0x7f800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x2b94, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x80800000, 0x80800000, 0x3400080}, +{0x3400000, 0x2b94, 0x80800002, 0x80800002, 0x3400080}, +{0x3400000, 0x2b94, 0x81398437, 0x81398437, 0x3400080}, +{0x3400000, 0x2b94, 0x8ba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x2b94, 0x8ba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x2b94, 0xf51f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x2b94, 0xff7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x2b94, 0xff7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x2b94, 0xff800000, 0xff800000, 0x3400080}, +{0x3400000, 0x2b94, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0x4f3495cb, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x2b94, 0xe73a5134, 0xe73a5134, 0x3400080}, +{0x3400000, 0x2b94, 0x7c994e9e, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x2b94, 0x6164bd6c, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x2b94, 0x9503366, 0x9503366, 0x3400080}, +{0x3400000, 0x2b94, 0xbf5a97c9, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0x2b94, 0xe6ff1a14, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0x2b94, 0x77f31e2f, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x2b94, 0xaab4d7d8, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0x2b94, 0x966320b, 0x966320b, 0x3400080}, +{0x3400000, 0x2b94, 0xb26bddee, 0xb26bddee, 0x3400080}, +{0x3400000, 0x2b94, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0x2b94, 0x317285d3, 0x317285d3, 0x3400080}, +{0x3400000, 0x2b94, 0x3c9623b1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x2b94, 0x51fd2c7c, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x2b94, 0x7b906a6c, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x636d24, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x800000, 0x800000, 0x3400080}, +{0x3400000, 0x636d24, 0x800002, 0x800002, 0x3400080}, +{0x3400000, 0x636d24, 0x1398437, 0x1398437, 0x3400080}, +{0x3400000, 0x636d24, 0xba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x636d24, 0xba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x636d24, 0x751f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x636d24, 0x7f7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x636d24, 0x7f7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x636d24, 0x7f800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x636d24, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x80800000, 0x80800000, 0x3400080}, +{0x3400000, 0x636d24, 0x80800002, 0x80800002, 0x3400080}, +{0x3400000, 0x636d24, 0x81398437, 0x81398437, 0x3400080}, +{0x3400000, 0x636d24, 0x8ba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x636d24, 0x8ba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x636d24, 0xf51f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x636d24, 0xff7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x636d24, 0xff7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x636d24, 0xff800000, 0xff800000, 0x3400080}, +{0x3400000, 0x636d24, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0x4f3495cb, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x636d24, 0xe73a5134, 0xe73a5134, 0x3400080}, +{0x3400000, 0x636d24, 0x7c994e9e, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x636d24, 0x6164bd6c, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x636d24, 0x9503366, 0x9503366, 0x3400080}, +{0x3400000, 0x636d24, 0xbf5a97c9, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0x636d24, 0xe6ff1a14, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0x636d24, 0x77f31e2f, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x636d24, 0xaab4d7d8, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0x636d24, 0x966320b, 0x966320b, 0x3400080}, +{0x3400000, 0x636d24, 0xb26bddee, 0xb26bddee, 0x3400080}, +{0x3400000, 0x636d24, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0x636d24, 0x317285d3, 0x317285d3, 0x3400080}, +{0x3400000, 0x636d24, 0x3c9623b1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x636d24, 0x51fd2c7c, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x636d24, 0x7b906a6c, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7fffff, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x800000, 0x800000, 0x3400080}, +{0x3400000, 0x7fffff, 0x800002, 0x800002, 0x3400080}, +{0x3400000, 0x7fffff, 0x1398437, 0x1398437, 0x3400080}, +{0x3400000, 0x7fffff, 0xba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x7fffff, 0xba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x7fffff, 0x751f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x7fffff, 0x7f7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7fffff, 0x7f7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7fffff, 0x7f800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x7fffff, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x80800000, 0x80800000, 0x3400080}, +{0x3400000, 0x7fffff, 0x80800002, 0x80800002, 0x3400080}, +{0x3400000, 0x7fffff, 0x81398437, 0x81398437, 0x3400080}, +{0x3400000, 0x7fffff, 0x8ba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x7fffff, 0x8ba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x7fffff, 0xf51f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x7fffff, 0xff7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x7fffff, 0xff7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x7fffff, 0xff800000, 0xff800000, 0x3400080}, +{0x3400000, 0x7fffff, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0x4f3495cb, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x7fffff, 0xe73a5134, 0xe73a5134, 0x3400080}, +{0x3400000, 0x7fffff, 0x7c994e9e, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7fffff, 0x6164bd6c, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x7fffff, 0x9503366, 0x9503366, 0x3400080}, +{0x3400000, 0x7fffff, 0xbf5a97c9, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0x7fffff, 0xe6ff1a14, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0x7fffff, 0x77f31e2f, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x7fffff, 0xaab4d7d8, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0x7fffff, 0x966320b, 0x966320b, 0x3400080}, +{0x3400000, 0x7fffff, 0xb26bddee, 0xb26bddee, 0x3400080}, +{0x3400000, 0x7fffff, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0x7fffff, 0x317285d3, 0x317285d3, 0x3400080}, +{0x3400000, 0x7fffff, 0x3c9623b1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x7fffff, 0x51fd2c7c, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x7fffff, 0x7b906a6c, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x800000, 0x0, 0x800000, 0x3400000}, +{0x3400000, 0x800000, 0x1, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x76, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x2b94, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x636d24, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x7fffff, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x800000, 0x1000000, 0x3400000}, +{0x3400000, 0x800000, 0x800002, 0x1000001, 0x3400000}, +{0x3400000, 0x800000, 0x1398437, 0x1798437, 0x3400000}, +{0x3400000, 0x800000, 0xba98d27, 0xba98d29, 0x3400000}, +{0x3400000, 0x800000, 0xba98d7a, 0xba98d7c, 0x3400000}, +{0x3400000, 0x800000, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x800000, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x800000, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x800000, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x800000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0x80000000, 0x800000, 0x3400000}, +{0x3400000, 0x800000, 0x80000001, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x80000076, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x80002b94, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x80636d24, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x807fffff, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x80800000, 0x0, 0x3400000}, +{0x3400000, 0x800000, 0x80800002, 0x0, 0x3400008}, +{0x3400000, 0x800000, 0x81398437, 0x80f3086e, 0x3400000}, +{0x3400000, 0x800000, 0x8ba98d27, 0x8ba98d25, 0x3400000}, +{0x3400000, 0x800000, 0x8ba98d7a, 0x8ba98d78, 0x3400000}, +{0x3400000, 0x800000, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x800000, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x800000, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x800000, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x800000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0x4f3495cb, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x800000, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0x800000, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x800000, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x800000, 0x9503366, 0x95033a6, 0x3400000}, +{0x3400000, 0x800000, 0xbf5a97c9, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0x800000, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0x800000, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0x800000, 0xaab4d7d8, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0x800000, 0x966320b, 0x966324b, 0x3400000}, +{0x3400000, 0x800000, 0xb26bddee, 0xb26bdded, 0x3400010}, +{0x3400000, 0x800000, 0xb5c8e5d3, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0x800000, 0x317285d3, 0x317285d4, 0x3400010}, +{0x3400000, 0x800000, 0x3c9623b1, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x800000, 0x51fd2c7c, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x800000, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x800002, 0x0, 0x800002, 0x3400000}, +{0x3400000, 0x800002, 0x1, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x76, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x2b94, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x636d24, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x7fffff, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x800000, 0x1000001, 0x3400000}, +{0x3400000, 0x800002, 0x800002, 0x1000002, 0x3400000}, +{0x3400000, 0x800002, 0x1398437, 0x1798438, 0x3400000}, +{0x3400000, 0x800002, 0xba98d27, 0xba98d2a, 0x3400010}, +{0x3400000, 0x800002, 0xba98d7a, 0xba98d7d, 0x3400010}, +{0x3400000, 0x800002, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x800002, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x800002, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x800002, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x800002, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0x80000000, 0x800002, 0x3400000}, +{0x3400000, 0x800002, 0x80000001, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x80000076, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x80002b94, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x80636d24, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x807fffff, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x80800000, 0x0, 0x3400008}, +{0x3400000, 0x800002, 0x80800002, 0x0, 0x3400000}, +{0x3400000, 0x800002, 0x81398437, 0x80f3086c, 0x3400000}, +{0x3400000, 0x800002, 0x8ba98d27, 0x8ba98d24, 0x3400010}, +{0x3400000, 0x800002, 0x8ba98d7a, 0x8ba98d77, 0x3400010}, +{0x3400000, 0x800002, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x800002, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x800002, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x800002, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x800002, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0x4f3495cb, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x800002, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0x800002, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x800002, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x800002, 0x9503366, 0x95033a7, 0x3400010}, +{0x3400000, 0x800002, 0xbf5a97c9, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0x800002, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0x800002, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0x800002, 0xaab4d7d8, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0x800002, 0x966320b, 0x966324c, 0x3400010}, +{0x3400000, 0x800002, 0xb26bddee, 0xb26bdded, 0x3400010}, +{0x3400000, 0x800002, 0xb5c8e5d3, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0x800002, 0x317285d3, 0x317285d4, 0x3400010}, +{0x3400000, 0x800002, 0x3c9623b1, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x800002, 0x51fd2c7c, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x800002, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x1398437, 0x0, 0x1398437, 0x3400000}, +{0x3400000, 0x1398437, 0x1, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x76, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x2b94, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x636d24, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x7fffff, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x800000, 0x1798437, 0x3400000}, +{0x3400000, 0x1398437, 0x800002, 0x1798438, 0x3400000}, +{0x3400000, 0x1398437, 0x1398437, 0x1b98437, 0x3400000}, +{0x3400000, 0x1398437, 0xba98d27, 0xba98d2d, 0x3400010}, +{0x3400000, 0x1398437, 0xba98d7a, 0xba98d80, 0x3400010}, +{0x3400000, 0x1398437, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x1398437, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x1398437, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x1398437, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x1398437, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0x80000000, 0x1398437, 0x3400000}, +{0x3400000, 0x1398437, 0x80000001, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x80000076, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x80002b94, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x80636d24, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x807fffff, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x80800000, 0xf3086e, 0x3400000}, +{0x3400000, 0x1398437, 0x80800002, 0xf3086c, 0x3400000}, +{0x3400000, 0x1398437, 0x81398437, 0x0, 0x3400000}, +{0x3400000, 0x1398437, 0x8ba98d27, 0x8ba98d21, 0x3400010}, +{0x3400000, 0x1398437, 0x8ba98d7a, 0x8ba98d74, 0x3400010}, +{0x3400000, 0x1398437, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x1398437, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x1398437, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x1398437, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x1398437, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0x4f3495cb, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x1398437, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0x1398437, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x1398437, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x1398437, 0x9503366, 0x9503420, 0x3400010}, +{0x3400000, 0x1398437, 0xbf5a97c9, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0x1398437, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0x1398437, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0x1398437, 0xaab4d7d8, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0x1398437, 0x966320b, 0x96632c5, 0x3400010}, +{0x3400000, 0x1398437, 0xb26bddee, 0xb26bdded, 0x3400010}, +{0x3400000, 0x1398437, 0xb5c8e5d3, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0x1398437, 0x317285d3, 0x317285d4, 0x3400010}, +{0x3400000, 0x1398437, 0x3c9623b1, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x1398437, 0x51fd2c7c, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x1398437, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0xba98d27, 0x0, 0xba98d27, 0x3400000}, +{0x3400000, 0xba98d27, 0x1, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x76, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x2b94, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x636d24, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x7fffff, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x800000, 0xba98d29, 0x3400000}, +{0x3400000, 0xba98d27, 0x800002, 0xba98d2a, 0x3400010}, +{0x3400000, 0xba98d27, 0x1398437, 0xba98d2d, 0x3400010}, +{0x3400000, 0xba98d27, 0xba98d27, 0xc298d27, 0x3400000}, +{0x3400000, 0xba98d27, 0xba98d7a, 0xc298d51, 0x3400010}, +{0x3400000, 0xba98d27, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0xba98d27, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0xba98d27, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0xba98d27, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xba98d27, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0x80000000, 0xba98d27, 0x3400000}, +{0x3400000, 0xba98d27, 0x80000001, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x80000076, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x80002b94, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x80636d24, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x807fffff, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x80800000, 0xba98d25, 0x3400000}, +{0x3400000, 0xba98d27, 0x80800002, 0xba98d25, 0x3400010}, +{0x3400000, 0xba98d27, 0x81398437, 0xba98d22, 0x3400010}, +{0x3400000, 0xba98d27, 0x8ba98d27, 0x0, 0x3400000}, +{0x3400000, 0xba98d27, 0x8ba98d7a, 0x83260000, 0x3400000}, +{0x3400000, 0xba98d27, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0xba98d27, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0xba98d27, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xba98d27, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xba98d27, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0x4f3495cb, 0x4f3495cc, 0x3400010}, +{0x3400000, 0xba98d27, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0xba98d27, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0xba98d27, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0xba98d27, 0x9503366, 0xbb00ec3, 0x3400010}, +{0x3400000, 0xba98d27, 0xbf5a97c9, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xba98d27, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xba98d27, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0xba98d27, 0xaab4d7d8, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xba98d27, 0x966320b, 0xbb0beb8, 0x3400010}, +{0x3400000, 0xba98d27, 0xb26bddee, 0xb26bdded, 0x3400010}, +{0x3400000, 0xba98d27, 0xb5c8e5d3, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xba98d27, 0x317285d3, 0x317285d4, 0x3400010}, +{0x3400000, 0xba98d27, 0x3c9623b1, 0x3c9623b2, 0x3400010}, +{0x3400000, 0xba98d27, 0x51fd2c7c, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0xba98d27, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0xba98d7a, 0x0, 0xba98d7a, 0x3400000}, +{0x3400000, 0xba98d7a, 0x1, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x76, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x2b94, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x636d24, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x7fffff, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x800000, 0xba98d7c, 0x3400000}, +{0x3400000, 0xba98d7a, 0x800002, 0xba98d7d, 0x3400010}, +{0x3400000, 0xba98d7a, 0x1398437, 0xba98d80, 0x3400010}, +{0x3400000, 0xba98d7a, 0xba98d27, 0xc298d51, 0x3400010}, +{0x3400000, 0xba98d7a, 0xba98d7a, 0xc298d7a, 0x3400000}, +{0x3400000, 0xba98d7a, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0xba98d7a, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0xba98d7a, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0xba98d7a, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x80000000, 0xba98d7a, 0x3400000}, +{0x3400000, 0xba98d7a, 0x80000001, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x80000076, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x80002b94, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x80636d24, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x807fffff, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x80800000, 0xba98d78, 0x3400000}, +{0x3400000, 0xba98d7a, 0x80800002, 0xba98d78, 0x3400010}, +{0x3400000, 0xba98d7a, 0x81398437, 0xba98d75, 0x3400010}, +{0x3400000, 0xba98d7a, 0x8ba98d27, 0x3260000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x8ba98d7a, 0x0, 0x3400000}, +{0x3400000, 0xba98d7a, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0xba98d7a, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0xba98d7a, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xba98d7a, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xba98d7a, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x4f3495cb, 0x4f3495cc, 0x3400010}, +{0x3400000, 0xba98d7a, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0xba98d7a, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0xba98d7a, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0xba98d7a, 0x9503366, 0xbb00f16, 0x3400010}, +{0x3400000, 0xba98d7a, 0xbf5a97c9, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xba98d7a, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xba98d7a, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0xba98d7a, 0xaab4d7d8, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xba98d7a, 0x966320b, 0xbb0bf0b, 0x3400010}, +{0x3400000, 0xba98d7a, 0xb26bddee, 0xb26bdded, 0x3400010}, +{0x3400000, 0xba98d7a, 0xb5c8e5d3, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xba98d7a, 0x317285d3, 0x317285d4, 0x3400010}, +{0x3400000, 0xba98d7a, 0x3c9623b1, 0x3c9623b2, 0x3400010}, +{0x3400000, 0xba98d7a, 0x51fd2c7c, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0xba98d7a, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x751f853a, 0x0, 0x751f853a, 0x3400000}, +{0x3400000, 0x751f853a, 0x1, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x76, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x2b94, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x636d24, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x7fffff, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x800000, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x800002, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x1398437, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0xba98d27, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0xba98d7a, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x751f853a, 0x759f853a, 0x3400000}, +{0x3400000, 0x751f853a, 0x7f7ffff0, 0x7f7ffffa, 0x3400010}, +{0x3400000, 0x751f853a, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x751f853a, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x751f853a, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0x80000000, 0x751f853a, 0x3400000}, +{0x3400000, 0x751f853a, 0x80000001, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x80000076, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x80002b94, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x80636d24, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x807fffff, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x80800000, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x80800002, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x81398437, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x8ba98d27, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x8ba98d7a, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0xf51f853a, 0x0, 0x3400000}, +{0x3400000, 0x751f853a, 0xff7ffff0, 0xff7fffe6, 0x3400010}, +{0x3400000, 0x751f853a, 0xff7fffff, 0xff7ffff5, 0x3400010}, +{0x3400000, 0x751f853a, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x751f853a, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0x4f3495cb, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0xe73a5134, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x7c994e9e, 0x7c994fde, 0x3400010}, +{0x3400000, 0x751f853a, 0x6164bd6c, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x9503366, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0xbf5a97c9, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0xe6ff1a14, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x77f31e2f, 0x77f81a59, 0x3400010}, +{0x3400000, 0x751f853a, 0xaab4d7d8, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x966320b, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0xb26bddee, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0xb5c8e5d3, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x317285d3, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x3c9623b1, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x51fd2c7c, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x7b906a6c, 0x7b906f69, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x0, 0x7f7ffff0, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x1, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x76, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x2b94, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x636d24, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x7fffff, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x800000, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x800002, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x1398437, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xba98d27, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xba98d7a, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x751f853a, 0x7f7ffffa, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x7f7ffff0, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7ffff0, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7ffff0, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x80000000, 0x7f7ffff0, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x80000001, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x80000076, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x80002b94, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x80636d24, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x807fffff, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x80800000, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x80800002, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x81398437, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x8ba98d27, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x8ba98d7a, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xf51f853a, 0x7f7fffe7, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xff7ffff0, 0x0, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0xff7fffff, 0xf5700000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x4f3495cb, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xe73a5134, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x7c994e9e, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7ffff0, 0x6164bd6c, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x9503366, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xbf5a97c9, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xe6ff1a14, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x77f31e2f, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7ffff0, 0xaab4d7d8, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x966320b, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xb26bddee, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xb5c8e5d3, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x317285d3, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x3c9623b1, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x51fd2c7c, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x7b906a6c, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x0, 0x7f7fffff, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x1, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x76, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x2b94, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x636d24, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x800000, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x800002, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x1398437, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xba98d27, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xba98d7a, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x751f853a, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x7f7ffff0, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x80000000, 0x7f7fffff, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x80000001, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x80000076, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x80002b94, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x80636d24, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x807fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x80800000, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x80800002, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x81398437, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x8ba98d27, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x8ba98d7a, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0xf51f853a, 0x7f7ffff6, 0x3400010}, +{0x3400000, 0x7f7fffff, 0xff7ffff0, 0x75700000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0xff7fffff, 0x0, 0x3400000}, +{0x3400000, 0x7f7fffff, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x4f3495cb, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xe73a5134, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x7c994e9e, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x6164bd6c, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x9503366, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xbf5a97c9, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0xe6ff1a14, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x77f31e2f, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xaab4d7d8, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x966320b, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xb26bddee, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0xb5c8e5d3, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x317285d3, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x3c9623b1, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x51fd2c7c, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x7b906a6c, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f800000, 0x0, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x1, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x76, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x2b94, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x636d24, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x7fffff, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x800002, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x1398437, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xba98d27, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xba98d7a, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x751f853a, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7f7ffff0, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7f7fffff, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0x80000000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x80000001, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x80000076, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x80002b94, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x80636d24, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x807fffff, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x80800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x80800002, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x81398437, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x8ba98d27, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x8ba98d7a, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xf51f853a, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xff7ffff0, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xff7fffff, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0x4f3495cb, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xe73a5134, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7c994e9e, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x6164bd6c, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x9503366, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xbf5a97c9, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xe6ff1a14, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x77f31e2f, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xaab4d7d8, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x966320b, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xb26bddee, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xb5c8e5d3, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x317285d3, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x3c9623b1, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x51fd2c7c, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7b906a6c, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800001, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0x0, 0x0, 0x3400000}, +{0x3400000, 0x80000000, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x80000000, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x80000000, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x80000000, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x80000000, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x80000000, 0x800000, 0x800000, 0x3400000}, +{0x3400000, 0x80000000, 0x800002, 0x800002, 0x3400000}, +{0x3400000, 0x80000000, 0x1398437, 0x1398437, 0x3400000}, +{0x3400000, 0x80000000, 0xba98d27, 0xba98d27, 0x3400000}, +{0x3400000, 0x80000000, 0xba98d7a, 0xba98d7a, 0x3400000}, +{0x3400000, 0x80000000, 0x751f853a, 0x751f853a, 0x3400000}, +{0x3400000, 0x80000000, 0x7f7ffff0, 0x7f7ffff0, 0x3400000}, +{0x3400000, 0x80000000, 0x7f7fffff, 0x7f7fffff, 0x3400000}, +{0x3400000, 0x80000000, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x80000000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0x80000000, 0x80000000, 0x3400000}, +{0x3400000, 0x80000000, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x80000000, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x80000000, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x80000000, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x80000000, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x80000000, 0x80800000, 0x80800000, 0x3400000}, +{0x3400000, 0x80000000, 0x80800002, 0x80800002, 0x3400000}, +{0x3400000, 0x80000000, 0x81398437, 0x81398437, 0x3400000}, +{0x3400000, 0x80000000, 0x8ba98d27, 0x8ba98d27, 0x3400000}, +{0x3400000, 0x80000000, 0x8ba98d7a, 0x8ba98d7a, 0x3400000}, +{0x3400000, 0x80000000, 0xf51f853a, 0xf51f853a, 0x3400000}, +{0x3400000, 0x80000000, 0xff7ffff0, 0xff7ffff0, 0x3400000}, +{0x3400000, 0x80000000, 0xff7fffff, 0xff7fffff, 0x3400000}, +{0x3400000, 0x80000000, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x80000000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0x4f3495cb, 0x4f3495cb, 0x3400000}, +{0x3400000, 0x80000000, 0xe73a5134, 0xe73a5134, 0x3400000}, +{0x3400000, 0x80000000, 0x7c994e9e, 0x7c994e9e, 0x3400000}, +{0x3400000, 0x80000000, 0x6164bd6c, 0x6164bd6c, 0x3400000}, +{0x3400000, 0x80000000, 0x9503366, 0x9503366, 0x3400000}, +{0x3400000, 0x80000000, 0xbf5a97c9, 0xbf5a97c9, 0x3400000}, +{0x3400000, 0x80000000, 0xe6ff1a14, 0xe6ff1a14, 0x3400000}, +{0x3400000, 0x80000000, 0x77f31e2f, 0x77f31e2f, 0x3400000}, +{0x3400000, 0x80000000, 0xaab4d7d8, 0xaab4d7d8, 0x3400000}, +{0x3400000, 0x80000000, 0x966320b, 0x966320b, 0x3400000}, +{0x3400000, 0x80000000, 0xb26bddee, 0xb26bddee, 0x3400000}, +{0x3400000, 0x80000000, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400000}, +{0x3400000, 0x80000000, 0x317285d3, 0x317285d3, 0x3400000}, +{0x3400000, 0x80000000, 0x3c9623b1, 0x3c9623b1, 0x3400000}, +{0x3400000, 0x80000000, 0x51fd2c7c, 0x51fd2c7c, 0x3400000}, +{0x3400000, 0x80000000, 0x7b906a6c, 0x7b906a6c, 0x3400000}, +{0x3400000, 0x80000001, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x800000, 0x800000, 0x3400080}, +{0x3400000, 0x80000001, 0x800002, 0x800002, 0x3400080}, +{0x3400000, 0x80000001, 0x1398437, 0x1398437, 0x3400080}, +{0x3400000, 0x80000001, 0xba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x80000001, 0xba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x80000001, 0x751f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x80000001, 0x7f7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x80000001, 0x7f7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x80000001, 0x7f800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x80000001, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x80800000, 0x80800000, 0x3400080}, +{0x3400000, 0x80000001, 0x80800002, 0x80800002, 0x3400080}, +{0x3400000, 0x80000001, 0x81398437, 0x81398437, 0x3400080}, +{0x3400000, 0x80000001, 0x8ba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x80000001, 0x8ba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x80000001, 0xf51f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x80000001, 0xff7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x80000001, 0xff7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x80000001, 0xff800000, 0xff800000, 0x3400080}, +{0x3400000, 0x80000001, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0x4f3495cb, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x80000001, 0xe73a5134, 0xe73a5134, 0x3400080}, +{0x3400000, 0x80000001, 0x7c994e9e, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x80000001, 0x6164bd6c, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x80000001, 0x9503366, 0x9503366, 0x3400080}, +{0x3400000, 0x80000001, 0xbf5a97c9, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0x80000001, 0xe6ff1a14, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0x80000001, 0x77f31e2f, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x80000001, 0xaab4d7d8, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0x80000001, 0x966320b, 0x966320b, 0x3400080}, +{0x3400000, 0x80000001, 0xb26bddee, 0xb26bddee, 0x3400080}, +{0x3400000, 0x80000001, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0x80000001, 0x317285d3, 0x317285d3, 0x3400080}, +{0x3400000, 0x80000001, 0x3c9623b1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x80000001, 0x51fd2c7c, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x80000001, 0x7b906a6c, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x80000076, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x800000, 0x800000, 0x3400080}, +{0x3400000, 0x80000076, 0x800002, 0x800002, 0x3400080}, +{0x3400000, 0x80000076, 0x1398437, 0x1398437, 0x3400080}, +{0x3400000, 0x80000076, 0xba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x80000076, 0xba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x80000076, 0x751f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x80000076, 0x7f7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x80000076, 0x7f7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x80000076, 0x7f800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x80000076, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x80800000, 0x80800000, 0x3400080}, +{0x3400000, 0x80000076, 0x80800002, 0x80800002, 0x3400080}, +{0x3400000, 0x80000076, 0x81398437, 0x81398437, 0x3400080}, +{0x3400000, 0x80000076, 0x8ba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x80000076, 0x8ba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x80000076, 0xf51f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x80000076, 0xff7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x80000076, 0xff7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x80000076, 0xff800000, 0xff800000, 0x3400080}, +{0x3400000, 0x80000076, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0x4f3495cb, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x80000076, 0xe73a5134, 0xe73a5134, 0x3400080}, +{0x3400000, 0x80000076, 0x7c994e9e, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x80000076, 0x6164bd6c, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x80000076, 0x9503366, 0x9503366, 0x3400080}, +{0x3400000, 0x80000076, 0xbf5a97c9, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0x80000076, 0xe6ff1a14, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0x80000076, 0x77f31e2f, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x80000076, 0xaab4d7d8, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0x80000076, 0x966320b, 0x966320b, 0x3400080}, +{0x3400000, 0x80000076, 0xb26bddee, 0xb26bddee, 0x3400080}, +{0x3400000, 0x80000076, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0x80000076, 0x317285d3, 0x317285d3, 0x3400080}, +{0x3400000, 0x80000076, 0x3c9623b1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x80000076, 0x51fd2c7c, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x80000076, 0x7b906a6c, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x80002b94, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x800000, 0x800000, 0x3400080}, +{0x3400000, 0x80002b94, 0x800002, 0x800002, 0x3400080}, +{0x3400000, 0x80002b94, 0x1398437, 0x1398437, 0x3400080}, +{0x3400000, 0x80002b94, 0xba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x80002b94, 0xba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x80002b94, 0x751f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x80002b94, 0x7f7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x80002b94, 0x7f7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x80002b94, 0x7f800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x80002b94, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x80800000, 0x80800000, 0x3400080}, +{0x3400000, 0x80002b94, 0x80800002, 0x80800002, 0x3400080}, +{0x3400000, 0x80002b94, 0x81398437, 0x81398437, 0x3400080}, +{0x3400000, 0x80002b94, 0x8ba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x80002b94, 0x8ba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x80002b94, 0xf51f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x80002b94, 0xff7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x80002b94, 0xff7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x80002b94, 0xff800000, 0xff800000, 0x3400080}, +{0x3400000, 0x80002b94, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0x4f3495cb, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x80002b94, 0xe73a5134, 0xe73a5134, 0x3400080}, +{0x3400000, 0x80002b94, 0x7c994e9e, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x80002b94, 0x6164bd6c, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x80002b94, 0x9503366, 0x9503366, 0x3400080}, +{0x3400000, 0x80002b94, 0xbf5a97c9, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0x80002b94, 0xe6ff1a14, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0x80002b94, 0x77f31e2f, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x80002b94, 0xaab4d7d8, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0x80002b94, 0x966320b, 0x966320b, 0x3400080}, +{0x3400000, 0x80002b94, 0xb26bddee, 0xb26bddee, 0x3400080}, +{0x3400000, 0x80002b94, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0x80002b94, 0x317285d3, 0x317285d3, 0x3400080}, +{0x3400000, 0x80002b94, 0x3c9623b1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x80002b94, 0x51fd2c7c, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x80002b94, 0x7b906a6c, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x80636d24, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x800000, 0x800000, 0x3400080}, +{0x3400000, 0x80636d24, 0x800002, 0x800002, 0x3400080}, +{0x3400000, 0x80636d24, 0x1398437, 0x1398437, 0x3400080}, +{0x3400000, 0x80636d24, 0xba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x80636d24, 0xba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x80636d24, 0x751f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x80636d24, 0x7f7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x80636d24, 0x7f7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x80636d24, 0x7f800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x80636d24, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x80800000, 0x80800000, 0x3400080}, +{0x3400000, 0x80636d24, 0x80800002, 0x80800002, 0x3400080}, +{0x3400000, 0x80636d24, 0x81398437, 0x81398437, 0x3400080}, +{0x3400000, 0x80636d24, 0x8ba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x80636d24, 0x8ba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x80636d24, 0xf51f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x80636d24, 0xff7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x80636d24, 0xff7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x80636d24, 0xff800000, 0xff800000, 0x3400080}, +{0x3400000, 0x80636d24, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0x4f3495cb, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x80636d24, 0xe73a5134, 0xe73a5134, 0x3400080}, +{0x3400000, 0x80636d24, 0x7c994e9e, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x80636d24, 0x6164bd6c, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x80636d24, 0x9503366, 0x9503366, 0x3400080}, +{0x3400000, 0x80636d24, 0xbf5a97c9, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0x80636d24, 0xe6ff1a14, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0x80636d24, 0x77f31e2f, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x80636d24, 0xaab4d7d8, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0x80636d24, 0x966320b, 0x966320b, 0x3400080}, +{0x3400000, 0x80636d24, 0xb26bddee, 0xb26bddee, 0x3400080}, +{0x3400000, 0x80636d24, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0x80636d24, 0x317285d3, 0x317285d3, 0x3400080}, +{0x3400000, 0x80636d24, 0x3c9623b1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x80636d24, 0x51fd2c7c, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x80636d24, 0x7b906a6c, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x807fffff, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x800000, 0x800000, 0x3400080}, +{0x3400000, 0x807fffff, 0x800002, 0x800002, 0x3400080}, +{0x3400000, 0x807fffff, 0x1398437, 0x1398437, 0x3400080}, +{0x3400000, 0x807fffff, 0xba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x807fffff, 0xba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x807fffff, 0x751f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x807fffff, 0x7f7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x807fffff, 0x7f7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x807fffff, 0x7f800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x807fffff, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x80800000, 0x80800000, 0x3400080}, +{0x3400000, 0x807fffff, 0x80800002, 0x80800002, 0x3400080}, +{0x3400000, 0x807fffff, 0x81398437, 0x81398437, 0x3400080}, +{0x3400000, 0x807fffff, 0x8ba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x807fffff, 0x8ba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x807fffff, 0xf51f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x807fffff, 0xff7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x807fffff, 0xff7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x807fffff, 0xff800000, 0xff800000, 0x3400080}, +{0x3400000, 0x807fffff, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0x4f3495cb, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x807fffff, 0xe73a5134, 0xe73a5134, 0x3400080}, +{0x3400000, 0x807fffff, 0x7c994e9e, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x807fffff, 0x6164bd6c, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x807fffff, 0x9503366, 0x9503366, 0x3400080}, +{0x3400000, 0x807fffff, 0xbf5a97c9, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0x807fffff, 0xe6ff1a14, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0x807fffff, 0x77f31e2f, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x807fffff, 0xaab4d7d8, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0x807fffff, 0x966320b, 0x966320b, 0x3400080}, +{0x3400000, 0x807fffff, 0xb26bddee, 0xb26bddee, 0x3400080}, +{0x3400000, 0x807fffff, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0x807fffff, 0x317285d3, 0x317285d3, 0x3400080}, +{0x3400000, 0x807fffff, 0x3c9623b1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x807fffff, 0x51fd2c7c, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x807fffff, 0x7b906a6c, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x80800000, 0x0, 0x80800000, 0x3400000}, +{0x3400000, 0x80800000, 0x1, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x76, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x2b94, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x636d24, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x7fffff, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x800000, 0x0, 0x3400000}, +{0x3400000, 0x80800000, 0x800002, 0x0, 0x3400008}, +{0x3400000, 0x80800000, 0x1398437, 0xf3086e, 0x3400000}, +{0x3400000, 0x80800000, 0xba98d27, 0xba98d25, 0x3400000}, +{0x3400000, 0x80800000, 0xba98d7a, 0xba98d78, 0x3400000}, +{0x3400000, 0x80800000, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0x80800000, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x80800000, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x80800000, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x80800000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0x80000000, 0x80800000, 0x3400000}, +{0x3400000, 0x80800000, 0x80000001, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x80000076, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x80002b94, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x80636d24, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x807fffff, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x80800000, 0x81000000, 0x3400000}, +{0x3400000, 0x80800000, 0x80800002, 0x81000001, 0x3400000}, +{0x3400000, 0x80800000, 0x81398437, 0x81798437, 0x3400000}, +{0x3400000, 0x80800000, 0x8ba98d27, 0x8ba98d29, 0x3400000}, +{0x3400000, 0x80800000, 0x8ba98d7a, 0x8ba98d7c, 0x3400000}, +{0x3400000, 0x80800000, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0x80800000, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0x80800000, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0x80800000, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x80800000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0x4f3495cb, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x80800000, 0xe73a5134, 0xe73a5134, 0x3400010}, +{0x3400000, 0x80800000, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x80800000, 0x6164bd6c, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x80800000, 0x9503366, 0x9503326, 0x3400000}, +{0x3400000, 0x80800000, 0xbf5a97c9, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0x80800000, 0xe6ff1a14, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0x80800000, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x80800000, 0xaab4d7d8, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0x80800000, 0x966320b, 0x96631cb, 0x3400000}, +{0x3400000, 0x80800000, 0xb26bddee, 0xb26bddee, 0x3400010}, +{0x3400000, 0x80800000, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0x80800000, 0x317285d3, 0x317285d3, 0x3400010}, +{0x3400000, 0x80800000, 0x3c9623b1, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x80800000, 0x51fd2c7c, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x80800000, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x80800002, 0x0, 0x80800002, 0x3400000}, +{0x3400000, 0x80800002, 0x1, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x76, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x2b94, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x636d24, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x7fffff, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x800000, 0x0, 0x3400008}, +{0x3400000, 0x80800002, 0x800002, 0x0, 0x3400000}, +{0x3400000, 0x80800002, 0x1398437, 0xf3086c, 0x3400000}, +{0x3400000, 0x80800002, 0xba98d27, 0xba98d25, 0x3400010}, +{0x3400000, 0x80800002, 0xba98d7a, 0xba98d78, 0x3400010}, +{0x3400000, 0x80800002, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0x80800002, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x80800002, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x80800002, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x80800002, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0x80000000, 0x80800002, 0x3400000}, +{0x3400000, 0x80800002, 0x80000001, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x80000076, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x80002b94, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x80636d24, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x807fffff, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x80800000, 0x81000001, 0x3400000}, +{0x3400000, 0x80800002, 0x80800002, 0x81000002, 0x3400000}, +{0x3400000, 0x80800002, 0x81398437, 0x81798438, 0x3400000}, +{0x3400000, 0x80800002, 0x8ba98d27, 0x8ba98d29, 0x3400010}, +{0x3400000, 0x80800002, 0x8ba98d7a, 0x8ba98d7c, 0x3400010}, +{0x3400000, 0x80800002, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0x80800002, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0x80800002, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0x80800002, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x80800002, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0x4f3495cb, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x80800002, 0xe73a5134, 0xe73a5134, 0x3400010}, +{0x3400000, 0x80800002, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x80800002, 0x6164bd6c, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x80800002, 0x9503366, 0x9503326, 0x3400010}, +{0x3400000, 0x80800002, 0xbf5a97c9, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0x80800002, 0xe6ff1a14, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0x80800002, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x80800002, 0xaab4d7d8, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0x80800002, 0x966320b, 0x96631cb, 0x3400010}, +{0x3400000, 0x80800002, 0xb26bddee, 0xb26bddee, 0x3400010}, +{0x3400000, 0x80800002, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0x80800002, 0x317285d3, 0x317285d3, 0x3400010}, +{0x3400000, 0x80800002, 0x3c9623b1, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x80800002, 0x51fd2c7c, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x80800002, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x81398437, 0x0, 0x81398437, 0x3400000}, +{0x3400000, 0x81398437, 0x1, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x76, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x2b94, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x636d24, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x7fffff, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x800000, 0x80f3086e, 0x3400000}, +{0x3400000, 0x81398437, 0x800002, 0x80f3086c, 0x3400000}, +{0x3400000, 0x81398437, 0x1398437, 0x0, 0x3400000}, +{0x3400000, 0x81398437, 0xba98d27, 0xba98d22, 0x3400010}, +{0x3400000, 0x81398437, 0xba98d7a, 0xba98d75, 0x3400010}, +{0x3400000, 0x81398437, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0x81398437, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x81398437, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x81398437, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x81398437, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0x80000000, 0x81398437, 0x3400000}, +{0x3400000, 0x81398437, 0x80000001, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x80000076, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x80002b94, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x80636d24, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x807fffff, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x80800000, 0x81798437, 0x3400000}, +{0x3400000, 0x81398437, 0x80800002, 0x81798438, 0x3400000}, +{0x3400000, 0x81398437, 0x81398437, 0x81b98437, 0x3400000}, +{0x3400000, 0x81398437, 0x8ba98d27, 0x8ba98d2c, 0x3400010}, +{0x3400000, 0x81398437, 0x8ba98d7a, 0x8ba98d7f, 0x3400010}, +{0x3400000, 0x81398437, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0x81398437, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0x81398437, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0x81398437, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x81398437, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0x4f3495cb, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x81398437, 0xe73a5134, 0xe73a5134, 0x3400010}, +{0x3400000, 0x81398437, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x81398437, 0x6164bd6c, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x81398437, 0x9503366, 0x95032ad, 0x3400010}, +{0x3400000, 0x81398437, 0xbf5a97c9, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0x81398437, 0xe6ff1a14, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0x81398437, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x81398437, 0xaab4d7d8, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0x81398437, 0x966320b, 0x9663152, 0x3400010}, +{0x3400000, 0x81398437, 0xb26bddee, 0xb26bddee, 0x3400010}, +{0x3400000, 0x81398437, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0x81398437, 0x317285d3, 0x317285d3, 0x3400010}, +{0x3400000, 0x81398437, 0x3c9623b1, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x81398437, 0x51fd2c7c, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x81398437, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x0, 0x8ba98d27, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x1, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x76, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x2b94, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x636d24, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x7fffff, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x800000, 0x8ba98d25, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x800002, 0x8ba98d24, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x1398437, 0x8ba98d21, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xba98d27, 0x0, 0x3400000}, +{0x3400000, 0x8ba98d27, 0xba98d7a, 0x3260000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x80000000, 0x8ba98d27, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x80000001, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x80000076, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x80002b94, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x80636d24, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x807fffff, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x80800000, 0x8ba98d29, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x80800002, 0x8ba98d29, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x81398437, 0x8ba98d2c, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x8ba98d27, 0x8c298d27, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x8ba98d7a, 0x8c298d50, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x4f3495cb, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xe73a5134, 0xe73a5134, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x6164bd6c, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x9503366, 0x8ba30b8b, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xbf5a97c9, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xe6ff1a14, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xaab4d7d8, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x966320b, 0x8ba25b96, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xb26bddee, 0xb26bddee, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x317285d3, 0x317285d3, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x3c9623b1, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x51fd2c7c, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x0, 0x8ba98d7a, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x1, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x76, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x2b94, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x636d24, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x7fffff, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x800000, 0x8ba98d78, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x800002, 0x8ba98d77, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x1398437, 0x8ba98d74, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xba98d27, 0x83260000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0xba98d7a, 0x0, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x80000000, 0x8ba98d7a, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x80000001, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x80000076, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x80002b94, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x80636d24, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x807fffff, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x80800000, 0x8ba98d7c, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x80800002, 0x8ba98d7c, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x81398437, 0x8ba98d7f, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x8ba98d27, 0x8c298d50, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x8ba98d7a, 0x8c298d7a, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x4f3495cb, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xe73a5134, 0xe73a5134, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x6164bd6c, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x9503366, 0x8ba30bde, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xbf5a97c9, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xe6ff1a14, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xaab4d7d8, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x966320b, 0x8ba25be9, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xb26bddee, 0xb26bddee, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xb5c8e5d3, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x317285d3, 0x317285d3, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x3c9623b1, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x51fd2c7c, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0xf51f853a, 0x0, 0xf51f853a, 0x3400000}, +{0x3400000, 0xf51f853a, 0x1, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x76, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x2b94, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x636d24, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x7fffff, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x800000, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x800002, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x1398437, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0xba98d27, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0xba98d7a, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x751f853a, 0x0, 0x3400000}, +{0x3400000, 0xf51f853a, 0x7f7ffff0, 0x7f7fffe7, 0x3400010}, +{0x3400000, 0xf51f853a, 0x7f7fffff, 0x7f7ffff6, 0x3400010}, +{0x3400000, 0xf51f853a, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xf51f853a, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0x80000000, 0xf51f853a, 0x3400000}, +{0x3400000, 0xf51f853a, 0x80000001, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x80000076, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x80002b94, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x80636d24, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x807fffff, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x80800000, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x80800002, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x81398437, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x8ba98d27, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x8ba98d7a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0xf51f853a, 0xf59f853a, 0x3400000}, +{0x3400000, 0xf51f853a, 0xff7ffff0, 0xff7ffff9, 0x3400010}, +{0x3400000, 0xf51f853a, 0xff7fffff, 0xff7fffff, 0x3400014}, +{0x3400000, 0xf51f853a, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xf51f853a, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0x4f3495cb, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0xe73a5134, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x7c994e9e, 0x7c994d5f, 0x3400010}, +{0x3400000, 0xf51f853a, 0x6164bd6c, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x9503366, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0xbf5a97c9, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0xe6ff1a14, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x77f31e2f, 0x77ee2206, 0x3400010}, +{0x3400000, 0xf51f853a, 0xaab4d7d8, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x966320b, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0xb26bddee, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0xb5c8e5d3, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x317285d3, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x3c9623b1, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x51fd2c7c, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x7b906a6c, 0x7b906570, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x0, 0xff7ffff0, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x1, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x76, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x2b94, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x636d24, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x7fffff, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x800000, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x800002, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x1398437, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xba98d27, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xba98d7a, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x751f853a, 0xff7fffe6, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x7f7ffff0, 0x0, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x7f7fffff, 0x75700000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x80000000, 0xff7ffff0, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x80000001, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x80000076, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x80002b94, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x80636d24, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x807fffff, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x80800000, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x80800002, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x81398437, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x8ba98d27, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x8ba98d7a, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xf51f853a, 0xff7ffff9, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xff7ffff0, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7ffff0, 0xff7fffff, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7ffff0, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x4f3495cb, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xe73a5134, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x7c994e9e, 0xff7b357b, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x6164bd6c, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x9503366, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xbf5a97c9, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xe6ff1a14, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x77f31e2f, 0xff7ffe09, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xaab4d7d8, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x966320b, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xb26bddee, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xb5c8e5d3, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x317285d3, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x3c9623b1, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x51fd2c7c, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x7b906a6c, 0xff7edf1b, 0x3400010}, +{0x3400000, 0xff7fffff, 0x0, 0xff7fffff, 0x3400000}, +{0x3400000, 0xff7fffff, 0x1, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x76, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x2b94, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x636d24, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x800000, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x800002, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x1398437, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0xba98d27, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0xba98d7a, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x751f853a, 0xff7ffff5, 0x3400010}, +{0x3400000, 0xff7fffff, 0x7f7ffff0, 0xf5700000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x7f7fffff, 0x0, 0x3400000}, +{0x3400000, 0xff7fffff, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x80000000, 0xff7fffff, 0x3400000}, +{0x3400000, 0xff7fffff, 0x80000001, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x80000076, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x80002b94, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x80636d24, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x807fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x80800000, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x80800002, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x81398437, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x8ba98d27, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x8ba98d7a, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0xf51f853a, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7fffff, 0xff7ffff0, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7fffff, 0xff7fffff, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7fffff, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xff7fffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x4f3495cb, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0xe73a5134, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x7c994e9e, 0xff7b358a, 0x3400010}, +{0x3400000, 0xff7fffff, 0x6164bd6c, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x9503366, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0xbf5a97c9, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0xe6ff1a14, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x77f31e2f, 0xff7ffe18, 0x3400010}, +{0x3400000, 0xff7fffff, 0xaab4d7d8, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x966320b, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0xb26bddee, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0xb5c8e5d3, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x317285d3, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x3c9623b1, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x51fd2c7c, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x7b906a6c, 0xff7edf2a, 0x3400010}, +{0x3400000, 0xff800000, 0x0, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x1, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x76, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x2b94, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x636d24, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x7fffff, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x800000, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x800002, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x1398437, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xba98d27, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xba98d7a, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x751f853a, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7f7ffff0, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7f7fffff, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0x80000000, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x80000001, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x80000076, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x80002b94, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x80636d24, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x807fffff, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x80800000, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x80800002, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x81398437, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x8ba98d27, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x8ba98d7a, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xf51f853a, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xff7ffff0, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xff7fffff, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0x4f3495cb, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xe73a5134, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7c994e9e, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x6164bd6c, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x9503366, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xbf5a97c9, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xe6ff1a14, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x77f31e2f, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xaab4d7d8, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x966320b, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xb26bddee, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xb5c8e5d3, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x317285d3, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x3c9623b1, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x51fd2c7c, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7b906a6c, 0xff800000, 0x3400000}, +{0x3400000, 0xff800001, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x0, 0x4f3495cb, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x1, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x76, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x2b94, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x636d24, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x7fffff, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x800000, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x800002, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x1398437, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xba98d27, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xba98d7a, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x4f3495cb, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x80000000, 0x4f3495cb, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x80000001, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x80000076, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x80002b94, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x80636d24, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x807fffff, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x80800000, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x80800002, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x81398437, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x8ba98d27, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x8ba98d7a, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x4f3495cb, 0x4fb495cb, 0x3400000}, +{0x3400000, 0x4f3495cb, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x9503366, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xbf5a97c9, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xaab4d7d8, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x966320b, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xb26bddee, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xb5c8e5d3, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x317285d3, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x3c9623b1, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x51fd2c7c, 0x52016896, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0xe73a5134, 0x0, 0xe73a5134, 0x3400000}, +{0x3400000, 0xe73a5134, 0x1, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x76, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x2b94, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x636d24, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x7fffff, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x800000, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x800002, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x1398437, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0xba98d27, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0xba98d7a, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xe73a5134, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xe73a5134, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xe73a5134, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xe73a5134, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0x80000000, 0xe73a5134, 0x3400000}, +{0x3400000, 0xe73a5134, 0x80000001, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x80000076, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x80002b94, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x80636d24, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x807fffff, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x80800000, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x80800002, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x81398437, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x8ba98d27, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x8ba98d7a, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xe73a5134, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xe73a5134, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xe73a5134, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xe73a5134, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0x4f3495cb, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0xe73a5134, 0xe7ba5134, 0x3400000}, +{0x3400000, 0xe73a5134, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0xe73a5134, 0x6164bd6c, 0xe73a42e8, 0x3400010}, +{0x3400000, 0xe73a5134, 0x9503366, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0xbf5a97c9, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0xe6ff1a14, 0xe79cef1f, 0x3400000}, +{0x3400000, 0xe73a5134, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0xe73a5134, 0xaab4d7d8, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x966320b, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0xb26bddee, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0xb5c8e5d3, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x317285d3, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x3c9623b1, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x51fd2c7c, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x0, 0x7c994e9e, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x1, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x76, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x2b94, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x636d24, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x7fffff, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x800000, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x800002, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x1398437, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xba98d27, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xba98d7a, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x751f853a, 0x7c994fde, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x7f7ffff0, 0x7f800000, 0x3400014}, +{0x3400000, 0x7c994e9e, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x7c994e9e, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x80000000, 0x7c994e9e, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x80000001, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x80000076, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x80002b94, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x80636d24, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x807fffff, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x80800000, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x80800002, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x81398437, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x8ba98d27, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x8ba98d7a, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xf51f853a, 0x7c994d5f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xff7ffff0, 0xff7b357b, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xff7fffff, 0xff7b358a, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x4f3495cb, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xe73a5134, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x7c994e9e, 0x7d194e9e, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x6164bd6c, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x9503366, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xbf5a97c9, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xe6ff1a14, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x77f31e2f, 0x7c998b66, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xaab4d7d8, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x966320b, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xb26bddee, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xb5c8e5d3, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x317285d3, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x3c9623b1, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x51fd2c7c, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x7b906a6c, 0x7cbd6939, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x0, 0x6164bd6c, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x1, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x76, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x2b94, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x636d24, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x7fffff, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x800000, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x800002, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x1398437, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xba98d27, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xba98d7a, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x6164bd6c, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x80000000, 0x6164bd6c, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x80000001, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x80000076, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x80002b94, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x80636d24, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x807fffff, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x80800000, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x80800002, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x81398437, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x8ba98d27, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x8ba98d7a, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x4f3495cb, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xe73a5134, 0xe73a42e8, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x6164bd6c, 0x61e4bd6c, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x9503366, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xbf5a97c9, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xe6ff1a14, 0xe6fefd7c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xaab4d7d8, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x966320b, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xb26bddee, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xb5c8e5d3, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x317285d3, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x3c9623b1, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x51fd2c7c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x9503366, 0x0, 0x9503366, 0x3400000}, +{0x3400000, 0x9503366, 0x1, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x76, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x2b94, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x636d24, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x7fffff, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x800000, 0x95033a6, 0x3400000}, +{0x3400000, 0x9503366, 0x800002, 0x95033a7, 0x3400010}, +{0x3400000, 0x9503366, 0x1398437, 0x9503420, 0x3400010}, +{0x3400000, 0x9503366, 0xba98d27, 0xbb00ec3, 0x3400010}, +{0x3400000, 0x9503366, 0xba98d7a, 0xbb00f16, 0x3400010}, +{0x3400000, 0x9503366, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x9503366, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x9503366, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x9503366, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x9503366, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0x80000000, 0x9503366, 0x3400000}, +{0x3400000, 0x9503366, 0x80000001, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x80000076, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x80002b94, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x80636d24, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x807fffff, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x80800000, 0x9503326, 0x3400000}, +{0x3400000, 0x9503366, 0x80800002, 0x9503326, 0x3400010}, +{0x3400000, 0x9503366, 0x81398437, 0x95032ad, 0x3400010}, +{0x3400000, 0x9503366, 0x8ba98d27, 0x8ba30b8b, 0x3400010}, +{0x3400000, 0x9503366, 0x8ba98d7a, 0x8ba30bde, 0x3400010}, +{0x3400000, 0x9503366, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x9503366, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x9503366, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x9503366, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x9503366, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0x4f3495cb, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x9503366, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0x9503366, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x9503366, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x9503366, 0x9503366, 0x9d03366, 0x3400000}, +{0x3400000, 0x9503366, 0xbf5a97c9, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0x9503366, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0x9503366, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0x9503366, 0xaab4d7d8, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0x9503366, 0x966320b, 0x9db32b9, 0x3400010}, +{0x3400000, 0x9503366, 0xb26bddee, 0xb26bdded, 0x3400010}, +{0x3400000, 0x9503366, 0xb5c8e5d3, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0x9503366, 0x317285d3, 0x317285d4, 0x3400010}, +{0x3400000, 0x9503366, 0x3c9623b1, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x9503366, 0x51fd2c7c, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x9503366, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x0, 0xbf5a97c9, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x1, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x76, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x2b94, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x636d24, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x7fffff, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x800000, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x800002, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x1398437, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xba98d27, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xba98d7a, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x80000000, 0xbf5a97c9, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x80000001, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x80000076, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x80002b94, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x80636d24, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x807fffff, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x80800000, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x80800002, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x81398437, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x8ba98d27, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x8ba98d7a, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x4f3495cb, 0x4f3495cb, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xe73a5134, 0xe73a5134, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x6164bd6c, 0x6164bd6c, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x9503366, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xbf5a97c9, 0xbfda97c9, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0xe6ff1a14, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xaab4d7d8, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x966320b, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xb26bddee, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xb5c8e5d3, 0xbf5a97e2, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x317285d3, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x3c9623b1, 0xbf55e6ab, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x51fd2c7c, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x0, 0xe6ff1a14, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x1, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x76, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x2b94, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x636d24, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x7fffff, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x800000, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x800002, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x1398437, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xba98d27, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xba98d7a, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x80000000, 0xe6ff1a14, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x80000001, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x80000076, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x80002b94, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x80636d24, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x807fffff, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x80800000, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x80800002, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x81398437, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x8ba98d27, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x8ba98d7a, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x4f3495cb, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xe73a5134, 0xe79cef1f, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x6164bd6c, 0xe6fefd7c, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x9503366, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xbf5a97c9, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xe6ff1a14, 0xe77f1a14, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xaab4d7d8, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x966320b, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xb26bddee, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xb5c8e5d3, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x317285d3, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x3c9623b1, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x51fd2c7c, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x0, 0x77f31e2f, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x1, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x76, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x2b94, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x636d24, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x7fffff, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x800000, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x800002, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x1398437, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xba98d27, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xba98d7a, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x751f853a, 0x77f81a59, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x7f7ffff0, 0x7f800000, 0x3400014}, +{0x3400000, 0x77f31e2f, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x77f31e2f, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x80000000, 0x77f31e2f, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x80000001, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x80000076, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x80002b94, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x80636d24, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x807fffff, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x80800000, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x80800002, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x81398437, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x8ba98d27, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x8ba98d7a, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xf51f853a, 0x77ee2206, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xff7ffff0, 0xff7ffe09, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xff7fffff, 0xff7ffe18, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x4f3495cb, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xe73a5134, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x7c994e9e, 0x7c998b66, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x6164bd6c, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x9503366, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xbf5a97c9, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xe6ff1a14, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x77f31e2f, 0x78731e2f, 0x3400000}, +{0x3400000, 0x77f31e2f, 0xaab4d7d8, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x966320b, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xb26bddee, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xb5c8e5d3, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x317285d3, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x3c9623b1, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x51fd2c7c, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x7b906a6c, 0x7b915d8b, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x0, 0xaab4d7d8, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x1, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x76, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x2b94, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x636d24, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x7fffff, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x800000, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x800002, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x1398437, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xba98d27, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xba98d7a, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x80000000, 0xaab4d7d8, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x80000001, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x80000076, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x80002b94, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x80636d24, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x807fffff, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x80800000, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x80800002, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x81398437, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x8ba98d27, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x8ba98d7a, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x4f3495cb, 0x4f3495cb, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xe73a5134, 0xe73a5134, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x6164bd6c, 0x6164bd6c, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x9503366, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xbf5a97c9, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xe6ff1a14, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xaab4d7d8, 0xab34d7d8, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x966320b, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xb26bddee, 0xb26bdf57, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xb5c8e5d3, 0xb5c8e5d5, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x317285d3, 0x3172802d, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x3c9623b1, 0x3c9623b1, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x51fd2c7c, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x966320b, 0x0, 0x966320b, 0x3400000}, +{0x3400000, 0x966320b, 0x1, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x76, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x2b94, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x636d24, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x7fffff, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x800000, 0x966324b, 0x3400000}, +{0x3400000, 0x966320b, 0x800002, 0x966324c, 0x3400010}, +{0x3400000, 0x966320b, 0x1398437, 0x96632c5, 0x3400010}, +{0x3400000, 0x966320b, 0xba98d27, 0xbb0beb8, 0x3400010}, +{0x3400000, 0x966320b, 0xba98d7a, 0xbb0bf0b, 0x3400010}, +{0x3400000, 0x966320b, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x966320b, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x966320b, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x966320b, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x966320b, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0x80000000, 0x966320b, 0x3400000}, +{0x3400000, 0x966320b, 0x80000001, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x80000076, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x80002b94, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x80636d24, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x807fffff, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x80800000, 0x96631cb, 0x3400000}, +{0x3400000, 0x966320b, 0x80800002, 0x96631cb, 0x3400010}, +{0x3400000, 0x966320b, 0x81398437, 0x9663152, 0x3400010}, +{0x3400000, 0x966320b, 0x8ba98d27, 0x8ba25b96, 0x3400010}, +{0x3400000, 0x966320b, 0x8ba98d7a, 0x8ba25be9, 0x3400010}, +{0x3400000, 0x966320b, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x966320b, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x966320b, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x966320b, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x966320b, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0x4f3495cb, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x966320b, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0x966320b, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x966320b, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x966320b, 0x9503366, 0x9db32b9, 0x3400010}, +{0x3400000, 0x966320b, 0xbf5a97c9, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0x966320b, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0x966320b, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0x966320b, 0xaab4d7d8, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0x966320b, 0x966320b, 0x9e6320b, 0x3400000}, +{0x3400000, 0x966320b, 0xb26bddee, 0xb26bdded, 0x3400010}, +{0x3400000, 0x966320b, 0xb5c8e5d3, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0x966320b, 0x317285d3, 0x317285d4, 0x3400010}, +{0x3400000, 0x966320b, 0x3c9623b1, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x966320b, 0x51fd2c7c, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x966320b, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0xb26bddee, 0x0, 0xb26bddee, 0x3400000}, +{0x3400000, 0xb26bddee, 0x1, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x76, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x2b94, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x636d24, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x7fffff, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x800000, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0x800002, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0x1398437, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0xba98d27, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0xba98d7a, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xb26bddee, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xb26bddee, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xb26bddee, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xb26bddee, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0x80000000, 0xb26bddee, 0x3400000}, +{0x3400000, 0xb26bddee, 0x80000001, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x80000076, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x80002b94, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x80636d24, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x807fffff, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x80800000, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0x80800002, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0x81398437, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0x8ba98d27, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0x8ba98d7a, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xb26bddee, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xb26bddee, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xb26bddee, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xb26bddee, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0x4f3495cb, 0x4f3495cb, 0x3400010}, +{0x3400000, 0xb26bddee, 0xe73a5134, 0xe73a5134, 0x3400010}, +{0x3400000, 0xb26bddee, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0xb26bddee, 0x6164bd6c, 0x6164bd6c, 0x3400010}, +{0x3400000, 0xb26bddee, 0x9503366, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0xbf5a97c9, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xb26bddee, 0xe6ff1a14, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xb26bddee, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0xb26bddee, 0xaab4d7d8, 0xb26bdf57, 0x3400010}, +{0x3400000, 0xb26bddee, 0x966320b, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0xb26bddee, 0xb2ebddee, 0x3400000}, +{0x3400000, 0xb26bddee, 0xb5c8e5d3, 0xb5cabd8e, 0x3400010}, +{0x3400000, 0xb26bddee, 0x317285d3, 0xb22f3c79, 0x3400010}, +{0x3400000, 0xb26bddee, 0x3c9623b1, 0x3c9623aa, 0x3400010}, +{0x3400000, 0xb26bddee, 0x51fd2c7c, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0xb26bddee, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x0, 0xb5c8e5d3, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x1, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x76, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x2b94, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x636d24, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x7fffff, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x800000, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x800002, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x1398437, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xba98d27, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xba98d7a, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x751f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x7f7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x7f7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x80000000, 0xb5c8e5d3, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x80000001, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x80000076, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x80002b94, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x80636d24, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x807fffff, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x80800000, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x80800002, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x81398437, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x8ba98d27, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x8ba98d7a, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xf51f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xff7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xff7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x4f3495cb, 0x4f3495cb, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xe73a5134, 0xe73a5134, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x7c994e9e, 0x7c994e9e, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x6164bd6c, 0x6164bd6c, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x9503366, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xbf5a97c9, 0xbf5a97e2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xe6ff1a14, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x77f31e2f, 0x77f31e2f, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xaab4d7d8, 0xb5c8e5d5, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x966320b, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xb26bddee, 0xb5cabd8e, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xb5c8e5d3, 0xb648e5d3, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x317285d3, 0xb5c86c90, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x3c9623b1, 0x3c96208e, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x51fd2c7c, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x7b906a6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x317285d3, 0x0, 0x317285d3, 0x3400000}, +{0x3400000, 0x317285d3, 0x1, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x76, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x2b94, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x636d24, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x7fffff, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x800000, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0x800002, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0x1398437, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0xba98d27, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0xba98d7a, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x317285d3, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x317285d3, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x317285d3, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x317285d3, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0x80000000, 0x317285d3, 0x3400000}, +{0x3400000, 0x317285d3, 0x80000001, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x80000076, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x80002b94, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x80636d24, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x807fffff, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x80800000, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0x80800002, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0x81398437, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0x8ba98d27, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0x8ba98d7a, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x317285d3, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x317285d3, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x317285d3, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x317285d3, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0x4f3495cb, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x317285d3, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0x317285d3, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x317285d3, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x317285d3, 0x9503366, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0xbf5a97c9, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0x317285d3, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0x317285d3, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0x317285d3, 0xaab4d7d8, 0x3172802d, 0x3400010}, +{0x3400000, 0x317285d3, 0x966320b, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0xb26bddee, 0xb22f3c79, 0x3400010}, +{0x3400000, 0x317285d3, 0xb5c8e5d3, 0xb5c86c90, 0x3400010}, +{0x3400000, 0x317285d3, 0x317285d3, 0x31f285d3, 0x3400000}, +{0x3400000, 0x317285d3, 0x3c9623b1, 0x3c9623b3, 0x3400010}, +{0x3400000, 0x317285d3, 0x51fd2c7c, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x317285d3, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x0, 0x3c9623b1, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x76, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x2b94, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x636d24, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x7fffff, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x800000, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x800002, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x1398437, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xba98d27, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xba98d7a, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x3c9623b1, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x80000000, 0x3c9623b1, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x80000001, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x80000076, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x80002b94, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x80636d24, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x807fffff, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x80800000, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x80800002, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x81398437, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x8ba98d27, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x8ba98d7a, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x4f3495cb, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x9503366, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xbf5a97c9, 0xbf55e6ab, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xaab4d7d8, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x966320b, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xb26bddee, 0x3c9623aa, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xb5c8e5d3, 0x3c96208e, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x317285d3, 0x3c9623b3, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x3c9623b1, 0x3d1623b1, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x51fd2c7c, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x0, 0x51fd2c7c, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x1, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x76, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x2b94, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x636d24, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x7fffff, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x800000, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x800002, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x1398437, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xba98d27, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xba98d7a, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x751f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x7f7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x51fd2c7c, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x80000000, 0x51fd2c7c, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x80000001, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x80000076, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x80002b94, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x80636d24, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x807fffff, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x80800000, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x80800002, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x81398437, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x8ba98d27, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x8ba98d7a, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xf51f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xff7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xff7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x4f3495cb, 0x52016896, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xe73a5134, 0xe73a5133, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x7c994e9e, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x6164bd6c, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x9503366, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xbf5a97c9, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xe6ff1a14, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x77f31e2f, 0x77f31e30, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xaab4d7d8, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x966320b, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xb26bddee, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xb5c8e5d3, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x317285d3, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x3c9623b1, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x51fd2c7c, 0x527d2c7c, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x7b906a6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x0, 0x7b906a6c, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x1, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x76, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x2b94, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x636d24, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x7fffff, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x800000, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x800002, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x1398437, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xba98d27, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xba98d7a, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x751f853a, 0x7b906f69, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x7f7ffff0, 0x7f800000, 0x3400014}, +{0x3400000, 0x7b906a6c, 0x7f7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x7b906a6c, 0x7f800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x80000000, 0x7b906a6c, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x80000001, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x80000076, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x80002b94, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x80636d24, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x807fffff, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x80800000, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x80800002, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x81398437, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x8ba98d27, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x8ba98d7a, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xf51f853a, 0x7b906570, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xff7ffff0, 0xff7edf1b, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xff7fffff, 0xff7edf2a, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xff800000, 0xff800000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x4f3495cb, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xe73a5134, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x7c994e9e, 0x7cbd6939, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x6164bd6c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x9503366, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xbf5a97c9, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xe6ff1a14, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x77f31e2f, 0x7b915d8b, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xaab4d7d8, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x966320b, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xb26bddee, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xb5c8e5d3, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x317285d3, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x3c9623b1, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x51fd2c7c, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x7b906a6c, 0x7c106a6c, 0x3400000}, +{0x3000000, 0x0, 0x0, 0x0, 0x3000000}, +{0x3000000, 0x0, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x800000, 0x800000, 0x3000000}, +{0x3000000, 0x0, 0x800002, 0x800002, 0x3000000}, +{0x3000000, 0x0, 0x1398437, 0x1398437, 0x3000000}, +{0x3000000, 0x0, 0xba98d27, 0xba98d27, 0x3000000}, +{0x3000000, 0x0, 0xba98d7a, 0xba98d7a, 0x3000000}, +{0x3000000, 0x0, 0x751f853a, 0x751f853a, 0x3000000}, +{0x3000000, 0x0, 0x7f7ffff0, 0x7f7ffff0, 0x3000000}, +{0x3000000, 0x0, 0x7f7fffff, 0x7f7fffff, 0x3000000}, +{0x3000000, 0x0, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x0, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0x80000000, 0x0, 0x3000000}, +{0x3000000, 0x0, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x80800000, 0x80800000, 0x3000000}, +{0x3000000, 0x0, 0x80800002, 0x80800002, 0x3000000}, +{0x3000000, 0x0, 0x81398437, 0x81398437, 0x3000000}, +{0x3000000, 0x0, 0x8ba98d27, 0x8ba98d27, 0x3000000}, +{0x3000000, 0x0, 0x8ba98d7a, 0x8ba98d7a, 0x3000000}, +{0x3000000, 0x0, 0xf51f853a, 0xf51f853a, 0x3000000}, +{0x3000000, 0x0, 0xff7ffff0, 0xff7ffff0, 0x3000000}, +{0x3000000, 0x0, 0xff7fffff, 0xff7fffff, 0x3000000}, +{0x3000000, 0x0, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x0, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0x4f3495cb, 0x4f3495cb, 0x3000000}, +{0x3000000, 0x0, 0xe73a5134, 0xe73a5134, 0x3000000}, +{0x3000000, 0x0, 0x7c994e9e, 0x7c994e9e, 0x3000000}, +{0x3000000, 0x0, 0x6164bd6c, 0x6164bd6c, 0x3000000}, +{0x3000000, 0x0, 0x9503366, 0x9503366, 0x3000000}, +{0x3000000, 0x0, 0xbf5a97c9, 0xbf5a97c9, 0x3000000}, +{0x3000000, 0x0, 0xe6ff1a14, 0xe6ff1a14, 0x3000000}, +{0x3000000, 0x0, 0x77f31e2f, 0x77f31e2f, 0x3000000}, +{0x3000000, 0x0, 0xaab4d7d8, 0xaab4d7d8, 0x3000000}, +{0x3000000, 0x0, 0x966320b, 0x966320b, 0x3000000}, +{0x3000000, 0x0, 0xb26bddee, 0xb26bddee, 0x3000000}, +{0x3000000, 0x0, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000000}, +{0x3000000, 0x0, 0x317285d3, 0x317285d3, 0x3000000}, +{0x3000000, 0x0, 0x3c9623b1, 0x3c9623b1, 0x3000000}, +{0x3000000, 0x0, 0x51fd2c7c, 0x51fd2c7c, 0x3000000}, +{0x3000000, 0x0, 0x7b906a6c, 0x7b906a6c, 0x3000000}, +{0x3000000, 0x1, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x800000, 0x800000, 0x3000080}, +{0x3000000, 0x1, 0x800002, 0x800002, 0x3000080}, +{0x3000000, 0x1, 0x1398437, 0x1398437, 0x3000080}, +{0x3000000, 0x1, 0xba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x1, 0xba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x1, 0x751f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x1, 0x7f7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x1, 0x7f7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x1, 0x7f800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x1, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x80800000, 0x80800000, 0x3000080}, +{0x3000000, 0x1, 0x80800002, 0x80800002, 0x3000080}, +{0x3000000, 0x1, 0x81398437, 0x81398437, 0x3000080}, +{0x3000000, 0x1, 0x8ba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x1, 0x8ba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x1, 0xf51f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x1, 0xff7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x1, 0xff7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x1, 0xff800000, 0xff800000, 0x3000080}, +{0x3000000, 0x1, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0x4f3495cb, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x1, 0xe73a5134, 0xe73a5134, 0x3000080}, +{0x3000000, 0x1, 0x7c994e9e, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x1, 0x6164bd6c, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x1, 0x9503366, 0x9503366, 0x3000080}, +{0x3000000, 0x1, 0xbf5a97c9, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0x1, 0xe6ff1a14, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0x1, 0x77f31e2f, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x1, 0xaab4d7d8, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0x1, 0x966320b, 0x966320b, 0x3000080}, +{0x3000000, 0x1, 0xb26bddee, 0xb26bddee, 0x3000080}, +{0x3000000, 0x1, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0x1, 0x317285d3, 0x317285d3, 0x3000080}, +{0x3000000, 0x1, 0x3c9623b1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x1, 0x51fd2c7c, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x1, 0x7b906a6c, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x76, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x800000, 0x800000, 0x3000080}, +{0x3000000, 0x76, 0x800002, 0x800002, 0x3000080}, +{0x3000000, 0x76, 0x1398437, 0x1398437, 0x3000080}, +{0x3000000, 0x76, 0xba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x76, 0xba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x76, 0x751f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x76, 0x7f7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x76, 0x7f7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x76, 0x7f800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x76, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x80800000, 0x80800000, 0x3000080}, +{0x3000000, 0x76, 0x80800002, 0x80800002, 0x3000080}, +{0x3000000, 0x76, 0x81398437, 0x81398437, 0x3000080}, +{0x3000000, 0x76, 0x8ba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x76, 0x8ba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x76, 0xf51f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x76, 0xff7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x76, 0xff7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x76, 0xff800000, 0xff800000, 0x3000080}, +{0x3000000, 0x76, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0x4f3495cb, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x76, 0xe73a5134, 0xe73a5134, 0x3000080}, +{0x3000000, 0x76, 0x7c994e9e, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x76, 0x6164bd6c, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x76, 0x9503366, 0x9503366, 0x3000080}, +{0x3000000, 0x76, 0xbf5a97c9, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0x76, 0xe6ff1a14, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0x76, 0x77f31e2f, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x76, 0xaab4d7d8, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0x76, 0x966320b, 0x966320b, 0x3000080}, +{0x3000000, 0x76, 0xb26bddee, 0xb26bddee, 0x3000080}, +{0x3000000, 0x76, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0x76, 0x317285d3, 0x317285d3, 0x3000080}, +{0x3000000, 0x76, 0x3c9623b1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x76, 0x51fd2c7c, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x76, 0x7b906a6c, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x2b94, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x800000, 0x800000, 0x3000080}, +{0x3000000, 0x2b94, 0x800002, 0x800002, 0x3000080}, +{0x3000000, 0x2b94, 0x1398437, 0x1398437, 0x3000080}, +{0x3000000, 0x2b94, 0xba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x2b94, 0xba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x2b94, 0x751f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x2b94, 0x7f7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x2b94, 0x7f7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x2b94, 0x7f800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x2b94, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x80800000, 0x80800000, 0x3000080}, +{0x3000000, 0x2b94, 0x80800002, 0x80800002, 0x3000080}, +{0x3000000, 0x2b94, 0x81398437, 0x81398437, 0x3000080}, +{0x3000000, 0x2b94, 0x8ba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x2b94, 0x8ba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x2b94, 0xf51f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x2b94, 0xff7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x2b94, 0xff7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x2b94, 0xff800000, 0xff800000, 0x3000080}, +{0x3000000, 0x2b94, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0x4f3495cb, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x2b94, 0xe73a5134, 0xe73a5134, 0x3000080}, +{0x3000000, 0x2b94, 0x7c994e9e, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x2b94, 0x6164bd6c, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x2b94, 0x9503366, 0x9503366, 0x3000080}, +{0x3000000, 0x2b94, 0xbf5a97c9, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0x2b94, 0xe6ff1a14, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0x2b94, 0x77f31e2f, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x2b94, 0xaab4d7d8, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0x2b94, 0x966320b, 0x966320b, 0x3000080}, +{0x3000000, 0x2b94, 0xb26bddee, 0xb26bddee, 0x3000080}, +{0x3000000, 0x2b94, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0x2b94, 0x317285d3, 0x317285d3, 0x3000080}, +{0x3000000, 0x2b94, 0x3c9623b1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x2b94, 0x51fd2c7c, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x2b94, 0x7b906a6c, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x636d24, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x800000, 0x800000, 0x3000080}, +{0x3000000, 0x636d24, 0x800002, 0x800002, 0x3000080}, +{0x3000000, 0x636d24, 0x1398437, 0x1398437, 0x3000080}, +{0x3000000, 0x636d24, 0xba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x636d24, 0xba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x636d24, 0x751f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x636d24, 0x7f7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x636d24, 0x7f7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x636d24, 0x7f800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x636d24, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x80800000, 0x80800000, 0x3000080}, +{0x3000000, 0x636d24, 0x80800002, 0x80800002, 0x3000080}, +{0x3000000, 0x636d24, 0x81398437, 0x81398437, 0x3000080}, +{0x3000000, 0x636d24, 0x8ba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x636d24, 0x8ba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x636d24, 0xf51f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x636d24, 0xff7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x636d24, 0xff7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x636d24, 0xff800000, 0xff800000, 0x3000080}, +{0x3000000, 0x636d24, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0x4f3495cb, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x636d24, 0xe73a5134, 0xe73a5134, 0x3000080}, +{0x3000000, 0x636d24, 0x7c994e9e, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x636d24, 0x6164bd6c, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x636d24, 0x9503366, 0x9503366, 0x3000080}, +{0x3000000, 0x636d24, 0xbf5a97c9, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0x636d24, 0xe6ff1a14, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0x636d24, 0x77f31e2f, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x636d24, 0xaab4d7d8, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0x636d24, 0x966320b, 0x966320b, 0x3000080}, +{0x3000000, 0x636d24, 0xb26bddee, 0xb26bddee, 0x3000080}, +{0x3000000, 0x636d24, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0x636d24, 0x317285d3, 0x317285d3, 0x3000080}, +{0x3000000, 0x636d24, 0x3c9623b1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x636d24, 0x51fd2c7c, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x636d24, 0x7b906a6c, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7fffff, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x800000, 0x800000, 0x3000080}, +{0x3000000, 0x7fffff, 0x800002, 0x800002, 0x3000080}, +{0x3000000, 0x7fffff, 0x1398437, 0x1398437, 0x3000080}, +{0x3000000, 0x7fffff, 0xba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x7fffff, 0xba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x7fffff, 0x751f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x7fffff, 0x7f7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7fffff, 0x7f7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7fffff, 0x7f800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x7fffff, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x80800000, 0x80800000, 0x3000080}, +{0x3000000, 0x7fffff, 0x80800002, 0x80800002, 0x3000080}, +{0x3000000, 0x7fffff, 0x81398437, 0x81398437, 0x3000080}, +{0x3000000, 0x7fffff, 0x8ba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x7fffff, 0x8ba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x7fffff, 0xf51f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x7fffff, 0xff7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x7fffff, 0xff7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x7fffff, 0xff800000, 0xff800000, 0x3000080}, +{0x3000000, 0x7fffff, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0x4f3495cb, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x7fffff, 0xe73a5134, 0xe73a5134, 0x3000080}, +{0x3000000, 0x7fffff, 0x7c994e9e, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7fffff, 0x6164bd6c, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x7fffff, 0x9503366, 0x9503366, 0x3000080}, +{0x3000000, 0x7fffff, 0xbf5a97c9, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0x7fffff, 0xe6ff1a14, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0x7fffff, 0x77f31e2f, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x7fffff, 0xaab4d7d8, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0x7fffff, 0x966320b, 0x966320b, 0x3000080}, +{0x3000000, 0x7fffff, 0xb26bddee, 0xb26bddee, 0x3000080}, +{0x3000000, 0x7fffff, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0x7fffff, 0x317285d3, 0x317285d3, 0x3000080}, +{0x3000000, 0x7fffff, 0x3c9623b1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x7fffff, 0x51fd2c7c, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x7fffff, 0x7b906a6c, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x800000, 0x0, 0x800000, 0x3000000}, +{0x3000000, 0x800000, 0x1, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x76, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x2b94, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x636d24, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x7fffff, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x800000, 0x1000000, 0x3000000}, +{0x3000000, 0x800000, 0x800002, 0x1000001, 0x3000000}, +{0x3000000, 0x800000, 0x1398437, 0x1798437, 0x3000000}, +{0x3000000, 0x800000, 0xba98d27, 0xba98d29, 0x3000000}, +{0x3000000, 0x800000, 0xba98d7a, 0xba98d7c, 0x3000000}, +{0x3000000, 0x800000, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x800000, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x800000, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x800000, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x800000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0x80000000, 0x800000, 0x3000000}, +{0x3000000, 0x800000, 0x80000001, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x80000076, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x80002b94, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x80636d24, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x807fffff, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x80800000, 0x0, 0x3000000}, +{0x3000000, 0x800000, 0x80800002, 0x0, 0x3000008}, +{0x3000000, 0x800000, 0x81398437, 0x80f3086e, 0x3000000}, +{0x3000000, 0x800000, 0x8ba98d27, 0x8ba98d25, 0x3000000}, +{0x3000000, 0x800000, 0x8ba98d7a, 0x8ba98d78, 0x3000000}, +{0x3000000, 0x800000, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x800000, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x800000, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x800000, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x800000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x800000, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x800000, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x800000, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x800000, 0x9503366, 0x95033a6, 0x3000000}, +{0x3000000, 0x800000, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x800000, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x800000, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x800000, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0x800000, 0x966320b, 0x966324b, 0x3000000}, +{0x3000000, 0x800000, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0x800000, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0x800000, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0x800000, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x800000, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x800000, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x800002, 0x0, 0x800002, 0x3000000}, +{0x3000000, 0x800002, 0x1, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x76, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x2b94, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x636d24, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x7fffff, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x800000, 0x1000001, 0x3000000}, +{0x3000000, 0x800002, 0x800002, 0x1000002, 0x3000000}, +{0x3000000, 0x800002, 0x1398437, 0x1798438, 0x3000000}, +{0x3000000, 0x800002, 0xba98d27, 0xba98d29, 0x3000010}, +{0x3000000, 0x800002, 0xba98d7a, 0xba98d7c, 0x3000010}, +{0x3000000, 0x800002, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x800002, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x800002, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x800002, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x800002, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0x80000000, 0x800002, 0x3000000}, +{0x3000000, 0x800002, 0x80000001, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x80000076, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x80002b94, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x80636d24, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x807fffff, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x80800000, 0x0, 0x3000008}, +{0x3000000, 0x800002, 0x80800002, 0x0, 0x3000000}, +{0x3000000, 0x800002, 0x81398437, 0x80f3086c, 0x3000000}, +{0x3000000, 0x800002, 0x8ba98d27, 0x8ba98d25, 0x3000010}, +{0x3000000, 0x800002, 0x8ba98d7a, 0x8ba98d78, 0x3000010}, +{0x3000000, 0x800002, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x800002, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x800002, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x800002, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x800002, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x800002, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x800002, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x800002, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x800002, 0x9503366, 0x95033a6, 0x3000010}, +{0x3000000, 0x800002, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x800002, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x800002, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x800002, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0x800002, 0x966320b, 0x966324b, 0x3000010}, +{0x3000000, 0x800002, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0x800002, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0x800002, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0x800002, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x800002, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x800002, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x1398437, 0x0, 0x1398437, 0x3000000}, +{0x3000000, 0x1398437, 0x1, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x76, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x2b94, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x636d24, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x7fffff, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x800000, 0x1798437, 0x3000000}, +{0x3000000, 0x1398437, 0x800002, 0x1798438, 0x3000000}, +{0x3000000, 0x1398437, 0x1398437, 0x1b98437, 0x3000000}, +{0x3000000, 0x1398437, 0xba98d27, 0xba98d2d, 0x3000010}, +{0x3000000, 0x1398437, 0xba98d7a, 0xba98d80, 0x3000010}, +{0x3000000, 0x1398437, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x1398437, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x1398437, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x1398437, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x1398437, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0x80000000, 0x1398437, 0x3000000}, +{0x3000000, 0x1398437, 0x80000001, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x80000076, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x80002b94, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x80636d24, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x807fffff, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x80800000, 0xf3086e, 0x3000000}, +{0x3000000, 0x1398437, 0x80800002, 0xf3086c, 0x3000000}, +{0x3000000, 0x1398437, 0x81398437, 0x0, 0x3000000}, +{0x3000000, 0x1398437, 0x8ba98d27, 0x8ba98d21, 0x3000010}, +{0x3000000, 0x1398437, 0x8ba98d7a, 0x8ba98d74, 0x3000010}, +{0x3000000, 0x1398437, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x1398437, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x1398437, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x1398437, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x1398437, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x1398437, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x1398437, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x1398437, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x1398437, 0x9503366, 0x9503420, 0x3000010}, +{0x3000000, 0x1398437, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x1398437, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x1398437, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x1398437, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0x1398437, 0x966320b, 0x96632c5, 0x3000010}, +{0x3000000, 0x1398437, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0x1398437, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0x1398437, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0x1398437, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x1398437, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x1398437, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0xba98d27, 0x0, 0xba98d27, 0x3000000}, +{0x3000000, 0xba98d27, 0x1, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x76, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x2b94, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x636d24, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x7fffff, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x800000, 0xba98d29, 0x3000000}, +{0x3000000, 0xba98d27, 0x800002, 0xba98d29, 0x3000010}, +{0x3000000, 0xba98d27, 0x1398437, 0xba98d2d, 0x3000010}, +{0x3000000, 0xba98d27, 0xba98d27, 0xc298d27, 0x3000000}, +{0x3000000, 0xba98d27, 0xba98d7a, 0xc298d50, 0x3000010}, +{0x3000000, 0xba98d27, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xba98d27, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xba98d27, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xba98d27, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xba98d27, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0x80000000, 0xba98d27, 0x3000000}, +{0x3000000, 0xba98d27, 0x80000001, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x80000076, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x80002b94, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x80636d24, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x807fffff, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x80800000, 0xba98d25, 0x3000000}, +{0x3000000, 0xba98d27, 0x80800002, 0xba98d25, 0x3000010}, +{0x3000000, 0xba98d27, 0x81398437, 0xba98d21, 0x3000010}, +{0x3000000, 0xba98d27, 0x8ba98d27, 0x0, 0x3000000}, +{0x3000000, 0xba98d27, 0x8ba98d7a, 0x83260000, 0x3000000}, +{0x3000000, 0xba98d27, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xba98d27, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xba98d27, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xba98d27, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xba98d27, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0xba98d27, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0xba98d27, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0xba98d27, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0xba98d27, 0x9503366, 0xbb00ec2, 0x3000010}, +{0x3000000, 0xba98d27, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xba98d27, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xba98d27, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0xba98d27, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xba98d27, 0x966320b, 0xbb0beb7, 0x3000010}, +{0x3000000, 0xba98d27, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0xba98d27, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xba98d27, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0xba98d27, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0xba98d27, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0xba98d27, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0xba98d7a, 0x0, 0xba98d7a, 0x3000000}, +{0x3000000, 0xba98d7a, 0x1, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x76, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x2b94, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x636d24, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x7fffff, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x800000, 0xba98d7c, 0x3000000}, +{0x3000000, 0xba98d7a, 0x800002, 0xba98d7c, 0x3000010}, +{0x3000000, 0xba98d7a, 0x1398437, 0xba98d80, 0x3000010}, +{0x3000000, 0xba98d7a, 0xba98d27, 0xc298d50, 0x3000010}, +{0x3000000, 0xba98d7a, 0xba98d7a, 0xc298d7a, 0x3000000}, +{0x3000000, 0xba98d7a, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xba98d7a, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xba98d7a, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xba98d7a, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x80000000, 0xba98d7a, 0x3000000}, +{0x3000000, 0xba98d7a, 0x80000001, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x80000076, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x80002b94, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x80636d24, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x807fffff, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x80800000, 0xba98d78, 0x3000000}, +{0x3000000, 0xba98d7a, 0x80800002, 0xba98d78, 0x3000010}, +{0x3000000, 0xba98d7a, 0x81398437, 0xba98d74, 0x3000010}, +{0x3000000, 0xba98d7a, 0x8ba98d27, 0x3260000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x8ba98d7a, 0x0, 0x3000000}, +{0x3000000, 0xba98d7a, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xba98d7a, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xba98d7a, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xba98d7a, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xba98d7a, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0xba98d7a, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0xba98d7a, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0xba98d7a, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0xba98d7a, 0x9503366, 0xbb00f15, 0x3000010}, +{0x3000000, 0xba98d7a, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xba98d7a, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xba98d7a, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0xba98d7a, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xba98d7a, 0x966320b, 0xbb0bf0a, 0x3000010}, +{0x3000000, 0xba98d7a, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0xba98d7a, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xba98d7a, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0xba98d7a, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0xba98d7a, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0xba98d7a, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x751f853a, 0x0, 0x751f853a, 0x3000000}, +{0x3000000, 0x751f853a, 0x1, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x76, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x2b94, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x636d24, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x7fffff, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x800000, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x800002, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x1398437, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xba98d27, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xba98d7a, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x751f853a, 0x759f853a, 0x3000000}, +{0x3000000, 0x751f853a, 0x7f7ffff0, 0x7f7ffffa, 0x3000010}, +{0x3000000, 0x751f853a, 0x7f7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x751f853a, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x751f853a, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0x80000000, 0x751f853a, 0x3000000}, +{0x3000000, 0x751f853a, 0x80000001, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x80000076, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x80002b94, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x80636d24, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x807fffff, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x80800000, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x80800002, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x81398437, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x8ba98d27, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x8ba98d7a, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xf51f853a, 0x0, 0x3000000}, +{0x3000000, 0x751f853a, 0xff7ffff0, 0xff7fffe6, 0x3000010}, +{0x3000000, 0x751f853a, 0xff7fffff, 0xff7ffff5, 0x3000010}, +{0x3000000, 0x751f853a, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x751f853a, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0x4f3495cb, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xe73a5134, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x7c994e9e, 0x7c994fdd, 0x3000010}, +{0x3000000, 0x751f853a, 0x6164bd6c, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x9503366, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xbf5a97c9, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xe6ff1a14, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x77f31e2f, 0x77f81a59, 0x3000010}, +{0x3000000, 0x751f853a, 0xaab4d7d8, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x966320b, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xb26bddee, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xb5c8e5d3, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x317285d3, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x3c9623b1, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x51fd2c7c, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x7b906a6c, 0x7b906f68, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x0, 0x7f7ffff0, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x1, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x76, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x2b94, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x636d24, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x7fffff, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x800000, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x800002, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x1398437, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xba98d27, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xba98d7a, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x751f853a, 0x7f7ffffa, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x7f7ffff0, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7ffff0, 0x7f7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7ffff0, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x80000000, 0x7f7ffff0, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x80000001, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x80000076, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x80002b94, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x80636d24, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x807fffff, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x80800000, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x80800002, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x81398437, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x8ba98d27, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x8ba98d7a, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xf51f853a, 0x7f7fffe6, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xff7ffff0, 0x0, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0xff7fffff, 0xf5700000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x4f3495cb, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xe73a5134, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x7c994e9e, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7ffff0, 0x6164bd6c, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x9503366, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xbf5a97c9, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xe6ff1a14, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x77f31e2f, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7ffff0, 0xaab4d7d8, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x966320b, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xb26bddee, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xb5c8e5d3, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x317285d3, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x3c9623b1, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x51fd2c7c, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x7b906a6c, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7fffff, 0x0, 0x7f7fffff, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x1, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x76, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x2b94, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x636d24, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x800000, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x800002, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x1398437, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xba98d27, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xba98d7a, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x751f853a, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7fffff, 0x7f7ffff0, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7fffff, 0x7f7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7fffff, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x80000000, 0x7f7fffff, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x80000001, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x80000076, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x80002b94, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x80636d24, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x807fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x80800000, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x80800002, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x81398437, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x8ba98d27, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x8ba98d7a, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xf51f853a, 0x7f7ffff5, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xff7ffff0, 0x75700000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0xff7fffff, 0x0, 0x3000000}, +{0x3000000, 0x7f7fffff, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x4f3495cb, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xe73a5134, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x7c994e9e, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7fffff, 0x6164bd6c, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x9503366, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xbf5a97c9, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xe6ff1a14, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x77f31e2f, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7fffff, 0xaab4d7d8, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x966320b, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xb26bddee, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xb5c8e5d3, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x317285d3, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x3c9623b1, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x51fd2c7c, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x7b906a6c, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f800000, 0x0, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x1, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x76, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x2b94, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x636d24, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x7fffff, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x800002, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x1398437, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xba98d27, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xba98d7a, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x751f853a, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7f7ffff0, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7f7fffff, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0x80000000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x80000001, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x80000076, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x80002b94, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x80636d24, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x807fffff, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x80800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x80800002, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x81398437, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x8ba98d27, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x8ba98d7a, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xf51f853a, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xff7ffff0, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xff7fffff, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0x4f3495cb, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xe73a5134, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7c994e9e, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x6164bd6c, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x9503366, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xbf5a97c9, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xe6ff1a14, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x77f31e2f, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xaab4d7d8, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x966320b, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xb26bddee, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xb5c8e5d3, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x317285d3, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x3c9623b1, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x51fd2c7c, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7b906a6c, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800001, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0x0, 0x0, 0x3000000}, +{0x3000000, 0x80000000, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x80000000, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x80000000, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x80000000, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x80000000, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x80000000, 0x800000, 0x800000, 0x3000000}, +{0x3000000, 0x80000000, 0x800002, 0x800002, 0x3000000}, +{0x3000000, 0x80000000, 0x1398437, 0x1398437, 0x3000000}, +{0x3000000, 0x80000000, 0xba98d27, 0xba98d27, 0x3000000}, +{0x3000000, 0x80000000, 0xba98d7a, 0xba98d7a, 0x3000000}, +{0x3000000, 0x80000000, 0x751f853a, 0x751f853a, 0x3000000}, +{0x3000000, 0x80000000, 0x7f7ffff0, 0x7f7ffff0, 0x3000000}, +{0x3000000, 0x80000000, 0x7f7fffff, 0x7f7fffff, 0x3000000}, +{0x3000000, 0x80000000, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x80000000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0x80000000, 0x80000000, 0x3000000}, +{0x3000000, 0x80000000, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x80000000, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x80000000, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x80000000, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x80000000, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x80000000, 0x80800000, 0x80800000, 0x3000000}, +{0x3000000, 0x80000000, 0x80800002, 0x80800002, 0x3000000}, +{0x3000000, 0x80000000, 0x81398437, 0x81398437, 0x3000000}, +{0x3000000, 0x80000000, 0x8ba98d27, 0x8ba98d27, 0x3000000}, +{0x3000000, 0x80000000, 0x8ba98d7a, 0x8ba98d7a, 0x3000000}, +{0x3000000, 0x80000000, 0xf51f853a, 0xf51f853a, 0x3000000}, +{0x3000000, 0x80000000, 0xff7ffff0, 0xff7ffff0, 0x3000000}, +{0x3000000, 0x80000000, 0xff7fffff, 0xff7fffff, 0x3000000}, +{0x3000000, 0x80000000, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x80000000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0x4f3495cb, 0x4f3495cb, 0x3000000}, +{0x3000000, 0x80000000, 0xe73a5134, 0xe73a5134, 0x3000000}, +{0x3000000, 0x80000000, 0x7c994e9e, 0x7c994e9e, 0x3000000}, +{0x3000000, 0x80000000, 0x6164bd6c, 0x6164bd6c, 0x3000000}, +{0x3000000, 0x80000000, 0x9503366, 0x9503366, 0x3000000}, +{0x3000000, 0x80000000, 0xbf5a97c9, 0xbf5a97c9, 0x3000000}, +{0x3000000, 0x80000000, 0xe6ff1a14, 0xe6ff1a14, 0x3000000}, +{0x3000000, 0x80000000, 0x77f31e2f, 0x77f31e2f, 0x3000000}, +{0x3000000, 0x80000000, 0xaab4d7d8, 0xaab4d7d8, 0x3000000}, +{0x3000000, 0x80000000, 0x966320b, 0x966320b, 0x3000000}, +{0x3000000, 0x80000000, 0xb26bddee, 0xb26bddee, 0x3000000}, +{0x3000000, 0x80000000, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000000}, +{0x3000000, 0x80000000, 0x317285d3, 0x317285d3, 0x3000000}, +{0x3000000, 0x80000000, 0x3c9623b1, 0x3c9623b1, 0x3000000}, +{0x3000000, 0x80000000, 0x51fd2c7c, 0x51fd2c7c, 0x3000000}, +{0x3000000, 0x80000000, 0x7b906a6c, 0x7b906a6c, 0x3000000}, +{0x3000000, 0x80000001, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x800000, 0x800000, 0x3000080}, +{0x3000000, 0x80000001, 0x800002, 0x800002, 0x3000080}, +{0x3000000, 0x80000001, 0x1398437, 0x1398437, 0x3000080}, +{0x3000000, 0x80000001, 0xba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x80000001, 0xba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x80000001, 0x751f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x80000001, 0x7f7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x80000001, 0x7f7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x80000001, 0x7f800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x80000001, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x80800000, 0x80800000, 0x3000080}, +{0x3000000, 0x80000001, 0x80800002, 0x80800002, 0x3000080}, +{0x3000000, 0x80000001, 0x81398437, 0x81398437, 0x3000080}, +{0x3000000, 0x80000001, 0x8ba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x80000001, 0x8ba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x80000001, 0xf51f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x80000001, 0xff7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x80000001, 0xff7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x80000001, 0xff800000, 0xff800000, 0x3000080}, +{0x3000000, 0x80000001, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0x4f3495cb, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x80000001, 0xe73a5134, 0xe73a5134, 0x3000080}, +{0x3000000, 0x80000001, 0x7c994e9e, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x80000001, 0x6164bd6c, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x80000001, 0x9503366, 0x9503366, 0x3000080}, +{0x3000000, 0x80000001, 0xbf5a97c9, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0x80000001, 0xe6ff1a14, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0x80000001, 0x77f31e2f, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x80000001, 0xaab4d7d8, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0x80000001, 0x966320b, 0x966320b, 0x3000080}, +{0x3000000, 0x80000001, 0xb26bddee, 0xb26bddee, 0x3000080}, +{0x3000000, 0x80000001, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0x80000001, 0x317285d3, 0x317285d3, 0x3000080}, +{0x3000000, 0x80000001, 0x3c9623b1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x80000001, 0x51fd2c7c, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x80000001, 0x7b906a6c, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x80000076, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x800000, 0x800000, 0x3000080}, +{0x3000000, 0x80000076, 0x800002, 0x800002, 0x3000080}, +{0x3000000, 0x80000076, 0x1398437, 0x1398437, 0x3000080}, +{0x3000000, 0x80000076, 0xba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x80000076, 0xba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x80000076, 0x751f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x80000076, 0x7f7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x80000076, 0x7f7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x80000076, 0x7f800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x80000076, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x80800000, 0x80800000, 0x3000080}, +{0x3000000, 0x80000076, 0x80800002, 0x80800002, 0x3000080}, +{0x3000000, 0x80000076, 0x81398437, 0x81398437, 0x3000080}, +{0x3000000, 0x80000076, 0x8ba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x80000076, 0x8ba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x80000076, 0xf51f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x80000076, 0xff7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x80000076, 0xff7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x80000076, 0xff800000, 0xff800000, 0x3000080}, +{0x3000000, 0x80000076, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0x4f3495cb, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x80000076, 0xe73a5134, 0xe73a5134, 0x3000080}, +{0x3000000, 0x80000076, 0x7c994e9e, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x80000076, 0x6164bd6c, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x80000076, 0x9503366, 0x9503366, 0x3000080}, +{0x3000000, 0x80000076, 0xbf5a97c9, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0x80000076, 0xe6ff1a14, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0x80000076, 0x77f31e2f, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x80000076, 0xaab4d7d8, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0x80000076, 0x966320b, 0x966320b, 0x3000080}, +{0x3000000, 0x80000076, 0xb26bddee, 0xb26bddee, 0x3000080}, +{0x3000000, 0x80000076, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0x80000076, 0x317285d3, 0x317285d3, 0x3000080}, +{0x3000000, 0x80000076, 0x3c9623b1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x80000076, 0x51fd2c7c, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x80000076, 0x7b906a6c, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x80002b94, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x800000, 0x800000, 0x3000080}, +{0x3000000, 0x80002b94, 0x800002, 0x800002, 0x3000080}, +{0x3000000, 0x80002b94, 0x1398437, 0x1398437, 0x3000080}, +{0x3000000, 0x80002b94, 0xba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x80002b94, 0xba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x80002b94, 0x751f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x80002b94, 0x7f7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x80002b94, 0x7f7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x80002b94, 0x7f800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x80002b94, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x80800000, 0x80800000, 0x3000080}, +{0x3000000, 0x80002b94, 0x80800002, 0x80800002, 0x3000080}, +{0x3000000, 0x80002b94, 0x81398437, 0x81398437, 0x3000080}, +{0x3000000, 0x80002b94, 0x8ba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x80002b94, 0x8ba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x80002b94, 0xf51f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x80002b94, 0xff7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x80002b94, 0xff7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x80002b94, 0xff800000, 0xff800000, 0x3000080}, +{0x3000000, 0x80002b94, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0x4f3495cb, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x80002b94, 0xe73a5134, 0xe73a5134, 0x3000080}, +{0x3000000, 0x80002b94, 0x7c994e9e, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x80002b94, 0x6164bd6c, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x80002b94, 0x9503366, 0x9503366, 0x3000080}, +{0x3000000, 0x80002b94, 0xbf5a97c9, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0x80002b94, 0xe6ff1a14, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0x80002b94, 0x77f31e2f, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x80002b94, 0xaab4d7d8, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0x80002b94, 0x966320b, 0x966320b, 0x3000080}, +{0x3000000, 0x80002b94, 0xb26bddee, 0xb26bddee, 0x3000080}, +{0x3000000, 0x80002b94, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0x80002b94, 0x317285d3, 0x317285d3, 0x3000080}, +{0x3000000, 0x80002b94, 0x3c9623b1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x80002b94, 0x51fd2c7c, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x80002b94, 0x7b906a6c, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x80636d24, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x800000, 0x800000, 0x3000080}, +{0x3000000, 0x80636d24, 0x800002, 0x800002, 0x3000080}, +{0x3000000, 0x80636d24, 0x1398437, 0x1398437, 0x3000080}, +{0x3000000, 0x80636d24, 0xba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x80636d24, 0xba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x80636d24, 0x751f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x80636d24, 0x7f7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x80636d24, 0x7f7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x80636d24, 0x7f800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x80636d24, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x80800000, 0x80800000, 0x3000080}, +{0x3000000, 0x80636d24, 0x80800002, 0x80800002, 0x3000080}, +{0x3000000, 0x80636d24, 0x81398437, 0x81398437, 0x3000080}, +{0x3000000, 0x80636d24, 0x8ba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x80636d24, 0x8ba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x80636d24, 0xf51f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x80636d24, 0xff7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x80636d24, 0xff7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x80636d24, 0xff800000, 0xff800000, 0x3000080}, +{0x3000000, 0x80636d24, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0x4f3495cb, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x80636d24, 0xe73a5134, 0xe73a5134, 0x3000080}, +{0x3000000, 0x80636d24, 0x7c994e9e, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x80636d24, 0x6164bd6c, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x80636d24, 0x9503366, 0x9503366, 0x3000080}, +{0x3000000, 0x80636d24, 0xbf5a97c9, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0x80636d24, 0xe6ff1a14, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0x80636d24, 0x77f31e2f, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x80636d24, 0xaab4d7d8, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0x80636d24, 0x966320b, 0x966320b, 0x3000080}, +{0x3000000, 0x80636d24, 0xb26bddee, 0xb26bddee, 0x3000080}, +{0x3000000, 0x80636d24, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0x80636d24, 0x317285d3, 0x317285d3, 0x3000080}, +{0x3000000, 0x80636d24, 0x3c9623b1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x80636d24, 0x51fd2c7c, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x80636d24, 0x7b906a6c, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x807fffff, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x800000, 0x800000, 0x3000080}, +{0x3000000, 0x807fffff, 0x800002, 0x800002, 0x3000080}, +{0x3000000, 0x807fffff, 0x1398437, 0x1398437, 0x3000080}, +{0x3000000, 0x807fffff, 0xba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x807fffff, 0xba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x807fffff, 0x751f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x807fffff, 0x7f7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x807fffff, 0x7f7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x807fffff, 0x7f800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x807fffff, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x80800000, 0x80800000, 0x3000080}, +{0x3000000, 0x807fffff, 0x80800002, 0x80800002, 0x3000080}, +{0x3000000, 0x807fffff, 0x81398437, 0x81398437, 0x3000080}, +{0x3000000, 0x807fffff, 0x8ba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x807fffff, 0x8ba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x807fffff, 0xf51f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x807fffff, 0xff7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x807fffff, 0xff7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x807fffff, 0xff800000, 0xff800000, 0x3000080}, +{0x3000000, 0x807fffff, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0x4f3495cb, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x807fffff, 0xe73a5134, 0xe73a5134, 0x3000080}, +{0x3000000, 0x807fffff, 0x7c994e9e, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x807fffff, 0x6164bd6c, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x807fffff, 0x9503366, 0x9503366, 0x3000080}, +{0x3000000, 0x807fffff, 0xbf5a97c9, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0x807fffff, 0xe6ff1a14, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0x807fffff, 0x77f31e2f, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x807fffff, 0xaab4d7d8, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0x807fffff, 0x966320b, 0x966320b, 0x3000080}, +{0x3000000, 0x807fffff, 0xb26bddee, 0xb26bddee, 0x3000080}, +{0x3000000, 0x807fffff, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0x807fffff, 0x317285d3, 0x317285d3, 0x3000080}, +{0x3000000, 0x807fffff, 0x3c9623b1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x807fffff, 0x51fd2c7c, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x807fffff, 0x7b906a6c, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x80800000, 0x0, 0x80800000, 0x3000000}, +{0x3000000, 0x80800000, 0x1, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x76, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x2b94, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x636d24, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x7fffff, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x800000, 0x0, 0x3000000}, +{0x3000000, 0x80800000, 0x800002, 0x0, 0x3000008}, +{0x3000000, 0x80800000, 0x1398437, 0xf3086e, 0x3000000}, +{0x3000000, 0x80800000, 0xba98d27, 0xba98d25, 0x3000000}, +{0x3000000, 0x80800000, 0xba98d7a, 0xba98d78, 0x3000000}, +{0x3000000, 0x80800000, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x80800000, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x80800000, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x80800000, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x80800000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0x80000000, 0x80800000, 0x3000000}, +{0x3000000, 0x80800000, 0x80000001, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x80000076, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x80002b94, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x80636d24, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x807fffff, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x80800000, 0x81000000, 0x3000000}, +{0x3000000, 0x80800000, 0x80800002, 0x81000001, 0x3000000}, +{0x3000000, 0x80800000, 0x81398437, 0x81798437, 0x3000000}, +{0x3000000, 0x80800000, 0x8ba98d27, 0x8ba98d29, 0x3000000}, +{0x3000000, 0x80800000, 0x8ba98d7a, 0x8ba98d7c, 0x3000000}, +{0x3000000, 0x80800000, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x80800000, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x80800000, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x80800000, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x80800000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x80800000, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x80800000, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x80800000, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x80800000, 0x9503366, 0x9503326, 0x3000000}, +{0x3000000, 0x80800000, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x80800000, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x80800000, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x80800000, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0x80800000, 0x966320b, 0x96631cb, 0x3000000}, +{0x3000000, 0x80800000, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0x80800000, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0x80800000, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0x80800000, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x80800000, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x80800000, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x80800002, 0x0, 0x80800002, 0x3000000}, +{0x3000000, 0x80800002, 0x1, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x76, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x2b94, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x636d24, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x7fffff, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x800000, 0x0, 0x3000008}, +{0x3000000, 0x80800002, 0x800002, 0x0, 0x3000000}, +{0x3000000, 0x80800002, 0x1398437, 0xf3086c, 0x3000000}, +{0x3000000, 0x80800002, 0xba98d27, 0xba98d25, 0x3000010}, +{0x3000000, 0x80800002, 0xba98d7a, 0xba98d78, 0x3000010}, +{0x3000000, 0x80800002, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x80800002, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x80800002, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x80800002, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x80800002, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0x80000000, 0x80800002, 0x3000000}, +{0x3000000, 0x80800002, 0x80000001, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x80000076, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x80002b94, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x80636d24, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x807fffff, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x80800000, 0x81000001, 0x3000000}, +{0x3000000, 0x80800002, 0x80800002, 0x81000002, 0x3000000}, +{0x3000000, 0x80800002, 0x81398437, 0x81798438, 0x3000000}, +{0x3000000, 0x80800002, 0x8ba98d27, 0x8ba98d29, 0x3000010}, +{0x3000000, 0x80800002, 0x8ba98d7a, 0x8ba98d7c, 0x3000010}, +{0x3000000, 0x80800002, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x80800002, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x80800002, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x80800002, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x80800002, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x80800002, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x80800002, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x80800002, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x80800002, 0x9503366, 0x9503326, 0x3000010}, +{0x3000000, 0x80800002, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x80800002, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x80800002, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x80800002, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0x80800002, 0x966320b, 0x96631cb, 0x3000010}, +{0x3000000, 0x80800002, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0x80800002, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0x80800002, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0x80800002, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x80800002, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x80800002, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x81398437, 0x0, 0x81398437, 0x3000000}, +{0x3000000, 0x81398437, 0x1, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x76, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x2b94, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x636d24, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x7fffff, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x800000, 0x80f3086e, 0x3000000}, +{0x3000000, 0x81398437, 0x800002, 0x80f3086c, 0x3000000}, +{0x3000000, 0x81398437, 0x1398437, 0x0, 0x3000000}, +{0x3000000, 0x81398437, 0xba98d27, 0xba98d21, 0x3000010}, +{0x3000000, 0x81398437, 0xba98d7a, 0xba98d74, 0x3000010}, +{0x3000000, 0x81398437, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x81398437, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x81398437, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x81398437, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x81398437, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0x80000000, 0x81398437, 0x3000000}, +{0x3000000, 0x81398437, 0x80000001, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x80000076, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x80002b94, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x80636d24, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x807fffff, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x80800000, 0x81798437, 0x3000000}, +{0x3000000, 0x81398437, 0x80800002, 0x81798438, 0x3000000}, +{0x3000000, 0x81398437, 0x81398437, 0x81b98437, 0x3000000}, +{0x3000000, 0x81398437, 0x8ba98d27, 0x8ba98d2d, 0x3000010}, +{0x3000000, 0x81398437, 0x8ba98d7a, 0x8ba98d80, 0x3000010}, +{0x3000000, 0x81398437, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x81398437, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x81398437, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x81398437, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x81398437, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x81398437, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x81398437, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x81398437, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x81398437, 0x9503366, 0x95032ac, 0x3000010}, +{0x3000000, 0x81398437, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x81398437, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x81398437, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x81398437, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0x81398437, 0x966320b, 0x9663151, 0x3000010}, +{0x3000000, 0x81398437, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0x81398437, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0x81398437, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0x81398437, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x81398437, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x81398437, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x0, 0x8ba98d27, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x1, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x76, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x2b94, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x636d24, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x7fffff, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x800000, 0x8ba98d25, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x800002, 0x8ba98d25, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x1398437, 0x8ba98d21, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xba98d27, 0x0, 0x3000000}, +{0x3000000, 0x8ba98d27, 0xba98d7a, 0x3260000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x80000000, 0x8ba98d27, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x80000001, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x80000076, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x80002b94, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x80636d24, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x807fffff, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x80800000, 0x8ba98d29, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x80800002, 0x8ba98d29, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x81398437, 0x8ba98d2d, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x8ba98d27, 0x8c298d27, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x8ba98d7a, 0x8c298d50, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x9503366, 0x8ba30b8c, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x966320b, 0x8ba25b97, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x0, 0x8ba98d7a, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x1, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x76, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x2b94, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x636d24, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x7fffff, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x800000, 0x8ba98d78, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x800002, 0x8ba98d78, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x1398437, 0x8ba98d74, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xba98d27, 0x83260000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0xba98d7a, 0x0, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x80000000, 0x8ba98d7a, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x80000001, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x80000076, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x80002b94, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x80636d24, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x807fffff, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x80800000, 0x8ba98d7c, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x80800002, 0x8ba98d7c, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x81398437, 0x8ba98d80, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x8ba98d27, 0x8c298d50, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x8ba98d7a, 0x8c298d7a, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x9503366, 0x8ba30bdf, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x966320b, 0x8ba25bea, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0xf51f853a, 0x0, 0xf51f853a, 0x3000000}, +{0x3000000, 0xf51f853a, 0x1, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x76, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x2b94, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x636d24, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x7fffff, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x800000, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x800002, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x1398437, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xba98d27, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xba98d7a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x751f853a, 0x0, 0x3000000}, +{0x3000000, 0xf51f853a, 0x7f7ffff0, 0x7f7fffe6, 0x3000010}, +{0x3000000, 0xf51f853a, 0x7f7fffff, 0x7f7ffff5, 0x3000010}, +{0x3000000, 0xf51f853a, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xf51f853a, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0x80000000, 0xf51f853a, 0x3000000}, +{0x3000000, 0xf51f853a, 0x80000001, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x80000076, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x80002b94, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x80636d24, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x807fffff, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x80800000, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x80800002, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x81398437, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x8ba98d27, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x8ba98d7a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xf51f853a, 0xf59f853a, 0x3000000}, +{0x3000000, 0xf51f853a, 0xff7ffff0, 0xff7ffffa, 0x3000010}, +{0x3000000, 0xf51f853a, 0xff7fffff, 0xff800000, 0x3000014}, +{0x3000000, 0xf51f853a, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xf51f853a, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0x4f3495cb, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xe73a5134, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x7c994e9e, 0x7c994d5f, 0x3000010}, +{0x3000000, 0xf51f853a, 0x6164bd6c, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x9503366, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xbf5a97c9, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xe6ff1a14, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x77f31e2f, 0x77ee2205, 0x3000010}, +{0x3000000, 0xf51f853a, 0xaab4d7d8, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x966320b, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xb26bddee, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xb5c8e5d3, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x317285d3, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x3c9623b1, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x51fd2c7c, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x7b906a6c, 0x7b906570, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x0, 0xff7ffff0, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x1, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x76, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x2b94, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x636d24, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x7fffff, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x800000, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x800002, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x1398437, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xba98d27, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xba98d7a, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x751f853a, 0xff7fffe6, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x7f7ffff0, 0x0, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x7f7fffff, 0x75700000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x80000000, 0xff7ffff0, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x80000001, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x80000076, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x80002b94, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x80636d24, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x807fffff, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x80800000, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x80800002, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x81398437, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x8ba98d27, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x8ba98d7a, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xf51f853a, 0xff7ffffa, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xff7ffff0, 0xff800000, 0x3000014}, +{0x3000000, 0xff7ffff0, 0xff7fffff, 0xff800000, 0x3000014}, +{0x3000000, 0xff7ffff0, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x4f3495cb, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xe73a5134, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x7c994e9e, 0xff7b357b, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x6164bd6c, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x9503366, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xbf5a97c9, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xe6ff1a14, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x77f31e2f, 0xff7ffe0a, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xaab4d7d8, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x966320b, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xb26bddee, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xb5c8e5d3, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x317285d3, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x3c9623b1, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x51fd2c7c, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x7b906a6c, 0xff7edf1b, 0x3000010}, +{0x3000000, 0xff7fffff, 0x0, 0xff7fffff, 0x3000000}, +{0x3000000, 0xff7fffff, 0x1, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x76, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x2b94, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x636d24, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x800000, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x800002, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x1398437, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xba98d27, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xba98d7a, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x751f853a, 0xff7ffff5, 0x3000010}, +{0x3000000, 0xff7fffff, 0x7f7ffff0, 0xf5700000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x7f7fffff, 0x0, 0x3000000}, +{0x3000000, 0xff7fffff, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x80000000, 0xff7fffff, 0x3000000}, +{0x3000000, 0xff7fffff, 0x80000001, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x80000076, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x80002b94, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x80636d24, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x807fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x80800000, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x80800002, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x81398437, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x8ba98d27, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x8ba98d7a, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xf51f853a, 0xff800000, 0x3000014}, +{0x3000000, 0xff7fffff, 0xff7ffff0, 0xff800000, 0x3000014}, +{0x3000000, 0xff7fffff, 0xff7fffff, 0xff800000, 0x3000014}, +{0x3000000, 0xff7fffff, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xff7fffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x4f3495cb, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xe73a5134, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x7c994e9e, 0xff7b358a, 0x3000010}, +{0x3000000, 0xff7fffff, 0x6164bd6c, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x9503366, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xbf5a97c9, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xe6ff1a14, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x77f31e2f, 0xff7ffe19, 0x3000010}, +{0x3000000, 0xff7fffff, 0xaab4d7d8, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x966320b, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xb26bddee, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xb5c8e5d3, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x317285d3, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x3c9623b1, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x51fd2c7c, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x7b906a6c, 0xff7edf2a, 0x3000010}, +{0x3000000, 0xff800000, 0x0, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x1, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x76, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x2b94, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x636d24, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x7fffff, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x800000, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x800002, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x1398437, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xba98d27, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xba98d7a, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x751f853a, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7f7ffff0, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7f7fffff, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0x80000000, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x80000001, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x80000076, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x80002b94, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x80636d24, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x807fffff, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x80800000, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x80800002, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x81398437, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x8ba98d27, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x8ba98d7a, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xf51f853a, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xff7ffff0, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xff7fffff, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0x4f3495cb, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xe73a5134, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7c994e9e, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x6164bd6c, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x9503366, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xbf5a97c9, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xe6ff1a14, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x77f31e2f, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xaab4d7d8, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x966320b, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xb26bddee, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xb5c8e5d3, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x317285d3, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x3c9623b1, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x51fd2c7c, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7b906a6c, 0xff800000, 0x3000000}, +{0x3000000, 0xff800001, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x0, 0x4f3495cb, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x1, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x76, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x2b94, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x636d24, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x7fffff, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x800000, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x800002, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x1398437, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xba98d27, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xba98d7a, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x80000000, 0x4f3495cb, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x80000001, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x80000076, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x80002b94, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x80636d24, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x807fffff, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x80800000, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x80800002, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x81398437, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x8ba98d27, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x8ba98d7a, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x4f3495cb, 0x4fb495cb, 0x3000000}, +{0x3000000, 0x4f3495cb, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x9503366, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xbf5a97c9, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xaab4d7d8, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x966320b, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xb26bddee, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xb5c8e5d3, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x317285d3, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x3c9623b1, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x51fd2c7c, 0x52016895, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0xe73a5134, 0x0, 0xe73a5134, 0x3000000}, +{0x3000000, 0xe73a5134, 0x1, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x76, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x2b94, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x636d24, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x7fffff, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x800000, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x800002, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x1398437, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xba98d27, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xba98d7a, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xe73a5134, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xe73a5134, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xe73a5134, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xe73a5134, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0x80000000, 0xe73a5134, 0x3000000}, +{0x3000000, 0xe73a5134, 0x80000001, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x80000076, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x80002b94, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x80636d24, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x807fffff, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x80800000, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x80800002, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x81398437, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x8ba98d27, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x8ba98d7a, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xe73a5134, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xe73a5134, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xe73a5134, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xe73a5134, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0x4f3495cb, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xe73a5134, 0xe7ba5134, 0x3000000}, +{0x3000000, 0xe73a5134, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0xe73a5134, 0x6164bd6c, 0xe73a42e8, 0x3000010}, +{0x3000000, 0xe73a5134, 0x9503366, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xbf5a97c9, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xe6ff1a14, 0xe79cef1f, 0x3000000}, +{0x3000000, 0xe73a5134, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0xe73a5134, 0xaab4d7d8, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x966320b, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xb26bddee, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xb5c8e5d3, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x317285d3, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x3c9623b1, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x51fd2c7c, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x0, 0x7c994e9e, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x1, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x76, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x2b94, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x636d24, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x7fffff, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x800000, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x800002, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x1398437, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xba98d27, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xba98d7a, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x751f853a, 0x7c994fdd, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x7f7ffff0, 0x7f800000, 0x3000014}, +{0x3000000, 0x7c994e9e, 0x7f7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x7c994e9e, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x80000000, 0x7c994e9e, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x80000001, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x80000076, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x80002b94, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x80636d24, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x807fffff, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x80800000, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x80800002, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x81398437, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x8ba98d27, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x8ba98d7a, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xf51f853a, 0x7c994d5f, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xff7ffff0, 0xff7b357b, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xff7fffff, 0xff7b358a, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x4f3495cb, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xe73a5134, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x7c994e9e, 0x7d194e9e, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x6164bd6c, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x9503366, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xbf5a97c9, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xe6ff1a14, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x77f31e2f, 0x7c998b66, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xaab4d7d8, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x966320b, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xb26bddee, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xb5c8e5d3, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x317285d3, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x3c9623b1, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x51fd2c7c, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x7b906a6c, 0x7cbd6939, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x0, 0x6164bd6c, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x1, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x76, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x2b94, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x636d24, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x7fffff, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x800000, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x800002, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x1398437, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xba98d27, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xba98d7a, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x80000000, 0x6164bd6c, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x80000001, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x80000076, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x80002b94, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x80636d24, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x807fffff, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x80800000, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x80800002, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x81398437, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x8ba98d27, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x8ba98d7a, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x4f3495cb, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xe73a5134, 0xe73a42e8, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x6164bd6c, 0x61e4bd6c, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x9503366, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xbf5a97c9, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xe6ff1a14, 0xe6fefd7c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xaab4d7d8, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x966320b, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xb26bddee, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xb5c8e5d3, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x317285d3, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x3c9623b1, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x51fd2c7c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x9503366, 0x0, 0x9503366, 0x3000000}, +{0x3000000, 0x9503366, 0x1, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x76, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x2b94, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x636d24, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x7fffff, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x800000, 0x95033a6, 0x3000000}, +{0x3000000, 0x9503366, 0x800002, 0x95033a6, 0x3000010}, +{0x3000000, 0x9503366, 0x1398437, 0x9503420, 0x3000010}, +{0x3000000, 0x9503366, 0xba98d27, 0xbb00ec2, 0x3000010}, +{0x3000000, 0x9503366, 0xba98d7a, 0xbb00f15, 0x3000010}, +{0x3000000, 0x9503366, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x9503366, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x9503366, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x9503366, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x9503366, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0x80000000, 0x9503366, 0x3000000}, +{0x3000000, 0x9503366, 0x80000001, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x80000076, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x80002b94, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x80636d24, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x807fffff, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x80800000, 0x9503326, 0x3000000}, +{0x3000000, 0x9503366, 0x80800002, 0x9503326, 0x3000010}, +{0x3000000, 0x9503366, 0x81398437, 0x95032ac, 0x3000010}, +{0x3000000, 0x9503366, 0x8ba98d27, 0x8ba30b8c, 0x3000010}, +{0x3000000, 0x9503366, 0x8ba98d7a, 0x8ba30bdf, 0x3000010}, +{0x3000000, 0x9503366, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x9503366, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x9503366, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x9503366, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x9503366, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x9503366, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x9503366, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x9503366, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x9503366, 0x9503366, 0x9d03366, 0x3000000}, +{0x3000000, 0x9503366, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x9503366, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x9503366, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x9503366, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0x9503366, 0x966320b, 0x9db32b8, 0x3000010}, +{0x3000000, 0x9503366, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0x9503366, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0x9503366, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0x9503366, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x9503366, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x9503366, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x0, 0xbf5a97c9, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x1, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x76, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x2b94, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x636d24, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x7fffff, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x800000, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x800002, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x1398437, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xba98d27, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xba98d7a, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x80000000, 0xbf5a97c9, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x80000001, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x80000076, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x80002b94, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x80636d24, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x807fffff, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x80800000, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x80800002, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x81398437, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x8ba98d27, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x8ba98d7a, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x9503366, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xbf5a97c9, 0xbfda97c9, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xaab4d7d8, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x966320b, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xb26bddee, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xb5c8e5d3, 0xbf5a97e2, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x317285d3, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x3c9623b1, 0xbf55e6ab, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x0, 0xe6ff1a14, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x1, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x76, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x2b94, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x636d24, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x7fffff, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x800000, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x800002, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x1398437, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xba98d27, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xba98d7a, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x80000000, 0xe6ff1a14, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x80000001, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x80000076, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x80002b94, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x80636d24, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x807fffff, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x80800000, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x80800002, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x81398437, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x8ba98d27, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x8ba98d7a, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x4f3495cb, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xe73a5134, 0xe79cef1f, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x6164bd6c, 0xe6fefd7c, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x9503366, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xbf5a97c9, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xe6ff1a14, 0xe77f1a14, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xaab4d7d8, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x966320b, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xb26bddee, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xb5c8e5d3, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x317285d3, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x3c9623b1, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x51fd2c7c, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x0, 0x77f31e2f, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x1, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x76, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x2b94, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x636d24, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x7fffff, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x800000, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x800002, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x1398437, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xba98d27, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xba98d7a, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x751f853a, 0x77f81a59, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x7f7ffff0, 0x7f800000, 0x3000014}, +{0x3000000, 0x77f31e2f, 0x7f7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x77f31e2f, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x80000000, 0x77f31e2f, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x80000001, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x80000076, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x80002b94, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x80636d24, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x807fffff, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x80800000, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x80800002, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x81398437, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x8ba98d27, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x8ba98d7a, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xf51f853a, 0x77ee2205, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xff7ffff0, 0xff7ffe0a, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xff7fffff, 0xff7ffe19, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x4f3495cb, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xe73a5134, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x7c994e9e, 0x7c998b66, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x6164bd6c, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x9503366, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xbf5a97c9, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xe6ff1a14, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x77f31e2f, 0x78731e2f, 0x3000000}, +{0x3000000, 0x77f31e2f, 0xaab4d7d8, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x966320b, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xb26bddee, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xb5c8e5d3, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x317285d3, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x3c9623b1, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x51fd2c7c, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x7b906a6c, 0x7b915d8a, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x0, 0xaab4d7d8, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x1, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x76, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x2b94, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x636d24, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x7fffff, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x800000, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x800002, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x1398437, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xba98d27, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xba98d7a, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x80000000, 0xaab4d7d8, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x80000001, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x80000076, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x80002b94, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x80636d24, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x807fffff, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x80800000, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x80800002, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x81398437, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x8ba98d27, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x8ba98d7a, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x9503366, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xaab4d7d8, 0xab34d7d8, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x966320b, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xb26bddee, 0xb26bdf58, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xb5c8e5d3, 0xb5c8e5d6, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x317285d3, 0x3172802c, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x966320b, 0x0, 0x966320b, 0x3000000}, +{0x3000000, 0x966320b, 0x1, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x76, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x2b94, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x636d24, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x7fffff, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x800000, 0x966324b, 0x3000000}, +{0x3000000, 0x966320b, 0x800002, 0x966324b, 0x3000010}, +{0x3000000, 0x966320b, 0x1398437, 0x96632c5, 0x3000010}, +{0x3000000, 0x966320b, 0xba98d27, 0xbb0beb7, 0x3000010}, +{0x3000000, 0x966320b, 0xba98d7a, 0xbb0bf0a, 0x3000010}, +{0x3000000, 0x966320b, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x966320b, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x966320b, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x966320b, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x966320b, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0x80000000, 0x966320b, 0x3000000}, +{0x3000000, 0x966320b, 0x80000001, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x80000076, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x80002b94, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x80636d24, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x807fffff, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x80800000, 0x96631cb, 0x3000000}, +{0x3000000, 0x966320b, 0x80800002, 0x96631cb, 0x3000010}, +{0x3000000, 0x966320b, 0x81398437, 0x9663151, 0x3000010}, +{0x3000000, 0x966320b, 0x8ba98d27, 0x8ba25b97, 0x3000010}, +{0x3000000, 0x966320b, 0x8ba98d7a, 0x8ba25bea, 0x3000010}, +{0x3000000, 0x966320b, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x966320b, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x966320b, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x966320b, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x966320b, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x966320b, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x966320b, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x966320b, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x966320b, 0x9503366, 0x9db32b8, 0x3000010}, +{0x3000000, 0x966320b, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x966320b, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x966320b, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x966320b, 0xaab4d7d8, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0x966320b, 0x966320b, 0x9e6320b, 0x3000000}, +{0x3000000, 0x966320b, 0xb26bddee, 0xb26bddee, 0x3000010}, +{0x3000000, 0x966320b, 0xb5c8e5d3, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0x966320b, 0x317285d3, 0x317285d3, 0x3000010}, +{0x3000000, 0x966320b, 0x3c9623b1, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x966320b, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x966320b, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0xb26bddee, 0x0, 0xb26bddee, 0x3000000}, +{0x3000000, 0xb26bddee, 0x1, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x76, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x2b94, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x636d24, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x7fffff, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x800000, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x800002, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x1398437, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0xba98d27, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0xba98d7a, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xb26bddee, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xb26bddee, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xb26bddee, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xb26bddee, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0x80000000, 0xb26bddee, 0x3000000}, +{0x3000000, 0xb26bddee, 0x80000001, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x80000076, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x80002b94, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x80636d24, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x807fffff, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x80800000, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x80800002, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x81398437, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x8ba98d27, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x8ba98d7a, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xb26bddee, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xb26bddee, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xb26bddee, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xb26bddee, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0xb26bddee, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0xb26bddee, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0xb26bddee, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0xb26bddee, 0x9503366, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xb26bddee, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xb26bddee, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0xb26bddee, 0xaab4d7d8, 0xb26bdf58, 0x3000010}, +{0x3000000, 0xb26bddee, 0x966320b, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0xb26bddee, 0xb2ebddee, 0x3000000}, +{0x3000000, 0xb26bddee, 0xb5c8e5d3, 0xb5cabd8f, 0x3000010}, +{0x3000000, 0xb26bddee, 0x317285d3, 0xb22f3c79, 0x3000010}, +{0x3000000, 0xb26bddee, 0x3c9623b1, 0x3c9623aa, 0x3000010}, +{0x3000000, 0xb26bddee, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0xb26bddee, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x0, 0xb5c8e5d3, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x1, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x76, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x2b94, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x636d24, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x7fffff, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x800000, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x800002, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x1398437, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xba98d27, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xba98d7a, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x80000000, 0xb5c8e5d3, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x80000001, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x80000076, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x80002b94, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x80636d24, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x807fffff, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x80800000, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x80800002, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x81398437, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x8ba98d27, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x8ba98d7a, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x9503366, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xbf5a97c9, 0xbf5a97e2, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xaab4d7d8, 0xb5c8e5d6, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x966320b, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xb26bddee, 0xb5cabd8f, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xb5c8e5d3, 0xb648e5d3, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x317285d3, 0xb5c86c90, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x3c9623b1, 0x3c96208d, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x317285d3, 0x0, 0x317285d3, 0x3000000}, +{0x3000000, 0x317285d3, 0x1, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x76, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x2b94, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x636d24, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x7fffff, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x800000, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x800002, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x1398437, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0xba98d27, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0xba98d7a, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x317285d3, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x317285d3, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x317285d3, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x317285d3, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0x80000000, 0x317285d3, 0x3000000}, +{0x3000000, 0x317285d3, 0x80000001, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x80000076, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x80002b94, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x80636d24, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x807fffff, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x80800000, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x80800002, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x81398437, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x8ba98d27, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x8ba98d7a, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x317285d3, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x317285d3, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x317285d3, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x317285d3, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x317285d3, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x317285d3, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x317285d3, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x317285d3, 0x9503366, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0xbf5a97c9, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0x317285d3, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x317285d3, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x317285d3, 0xaab4d7d8, 0x3172802c, 0x3000010}, +{0x3000000, 0x317285d3, 0x966320b, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0xb26bddee, 0xb22f3c79, 0x3000010}, +{0x3000000, 0x317285d3, 0xb5c8e5d3, 0xb5c86c90, 0x3000010}, +{0x3000000, 0x317285d3, 0x317285d3, 0x31f285d3, 0x3000000}, +{0x3000000, 0x317285d3, 0x3c9623b1, 0x3c9623b3, 0x3000010}, +{0x3000000, 0x317285d3, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x317285d3, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x0, 0x3c9623b1, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x76, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x2b94, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x636d24, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x7fffff, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x800000, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x800002, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x1398437, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xba98d27, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xba98d7a, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x80000000, 0x3c9623b1, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x80000001, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x80000076, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x80002b94, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x80636d24, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x807fffff, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x80800000, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x80800002, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x81398437, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x8ba98d27, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x8ba98d7a, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x4f3495cb, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x9503366, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xbf5a97c9, 0xbf55e6ab, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xaab4d7d8, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x966320b, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xb26bddee, 0x3c9623aa, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xb5c8e5d3, 0x3c96208d, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x317285d3, 0x3c9623b3, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x3c9623b1, 0x3d1623b1, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x51fd2c7c, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x0, 0x51fd2c7c, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x1, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x76, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x2b94, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x636d24, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x7fffff, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x800000, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x800002, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x1398437, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xba98d27, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xba98d7a, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x751f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x7f7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x7f7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x80000000, 0x51fd2c7c, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x80000001, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x80000076, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x80002b94, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x80636d24, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x807fffff, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x80800000, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x80800002, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x81398437, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x8ba98d27, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x8ba98d7a, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xf51f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xff7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xff7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x4f3495cb, 0x52016895, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xe73a5134, 0xe73a5134, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x7c994e9e, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x6164bd6c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x9503366, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xbf5a97c9, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xe6ff1a14, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x77f31e2f, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xaab4d7d8, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x966320b, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xb26bddee, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xb5c8e5d3, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x317285d3, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x3c9623b1, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x51fd2c7c, 0x527d2c7c, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x7b906a6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x0, 0x7b906a6c, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x1, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x76, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x2b94, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x636d24, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x7fffff, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x800000, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x800002, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x1398437, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xba98d27, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xba98d7a, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x751f853a, 0x7b906f68, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x7f7ffff0, 0x7f800000, 0x3000014}, +{0x3000000, 0x7b906a6c, 0x7f7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x7b906a6c, 0x7f800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x80000000, 0x7b906a6c, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x80000001, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x80000076, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x80002b94, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x80636d24, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x807fffff, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x80800000, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x80800002, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x81398437, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x8ba98d27, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x8ba98d7a, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xf51f853a, 0x7b906570, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xff7ffff0, 0xff7edf1b, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xff7fffff, 0xff7edf2a, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xff800000, 0xff800000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x4f3495cb, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xe73a5134, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x7c994e9e, 0x7cbd6939, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x6164bd6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x9503366, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xbf5a97c9, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xe6ff1a14, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x77f31e2f, 0x7b915d8a, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xaab4d7d8, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x966320b, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xb26bddee, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xb5c8e5d3, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x317285d3, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x3c9623b1, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x51fd2c7c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x7b906a6c, 0x7c106a6c, 0x3000000}, diff --git a/externals/dynarmic/tests/A32/vfp_vsub_f32.inc b/externals/dynarmic/tests/A32/vfp_vsub_f32.inc new file mode 100644 index 0000000000..792dd49e8c --- /dev/null +++ b/externals/dynarmic/tests/A32/vfp_vsub_f32.inc @@ -0,0 +1,13456 @@ +{0x3c00000, 0x0, 0x0, 0x0, 0x3c00000}, +{0x3c00000, 0x0, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x800000, 0x80800000, 0x3c00000}, +{0x3c00000, 0x0, 0x800002, 0x80800002, 0x3c00000}, +{0x3c00000, 0x0, 0x1398437, 0x81398437, 0x3c00000}, +{0x3c00000, 0x0, 0xba98d27, 0x8ba98d27, 0x3c00000}, +{0x3c00000, 0x0, 0xba98d7a, 0x8ba98d7a, 0x3c00000}, +{0x3c00000, 0x0, 0x751f853a, 0xf51f853a, 0x3c00000}, +{0x3c00000, 0x0, 0x7f7ffff0, 0xff7ffff0, 0x3c00000}, +{0x3c00000, 0x0, 0x7f7fffff, 0xff7fffff, 0x3c00000}, +{0x3c00000, 0x0, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x0, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0x80000000, 0x0, 0x3c00000}, +{0x3c00000, 0x0, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x0, 0x80800000, 0x800000, 0x3c00000}, +{0x3c00000, 0x0, 0x80800002, 0x800002, 0x3c00000}, +{0x3c00000, 0x0, 0x81398437, 0x1398437, 0x3c00000}, +{0x3c00000, 0x0, 0x8ba98d27, 0xba98d27, 0x3c00000}, +{0x3c00000, 0x0, 0x8ba98d7a, 0xba98d7a, 0x3c00000}, +{0x3c00000, 0x0, 0xf51f853a, 0x751f853a, 0x3c00000}, +{0x3c00000, 0x0, 0xff7ffff0, 0x7f7ffff0, 0x3c00000}, +{0x3c00000, 0x0, 0xff7fffff, 0x7f7fffff, 0x3c00000}, +{0x3c00000, 0x0, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x0, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x0, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x0, 0x4f3495cb, 0xcf3495cb, 0x3c00000}, +{0x3c00000, 0x0, 0xe73a5134, 0x673a5134, 0x3c00000}, +{0x3c00000, 0x0, 0x7c994e9e, 0xfc994e9e, 0x3c00000}, +{0x3c00000, 0x0, 0x6164bd6c, 0xe164bd6c, 0x3c00000}, +{0x3c00000, 0x0, 0x9503366, 0x89503366, 0x3c00000}, +{0x3c00000, 0x0, 0xbf5a97c9, 0x3f5a97c9, 0x3c00000}, +{0x3c00000, 0x0, 0xe6ff1a14, 0x66ff1a14, 0x3c00000}, +{0x3c00000, 0x0, 0x77f31e2f, 0xf7f31e2f, 0x3c00000}, +{0x3c00000, 0x0, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00000}, +{0x3c00000, 0x0, 0x966320b, 0x8966320b, 0x3c00000}, +{0x3c00000, 0x0, 0xb26bddee, 0x326bddee, 0x3c00000}, +{0x3c00000, 0x0, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00000}, +{0x3c00000, 0x0, 0x317285d3, 0xb17285d3, 0x3c00000}, +{0x3c00000, 0x0, 0x3c9623b1, 0xbc9623b1, 0x3c00000}, +{0x3c00000, 0x0, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00000}, +{0x3c00000, 0x0, 0x7b906a6c, 0xfb906a6c, 0x3c00000}, +{0x3c00000, 0x1, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x1, 0x800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x1, 0x1398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x1, 0xba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x1, 0xba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x1, 0x751f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x1, 0x7f7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x1, 0x7f7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x1, 0x7f800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x1, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x1, 0x80800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x1, 0x80800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x1, 0x81398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1, 0x8ba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x1, 0x8ba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x1, 0xf51f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x1, 0xff7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x1, 0xff7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x1, 0xff800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x1, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x1, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x1, 0x4f3495cb, 0xcf3495cb, 0x3c00080}, +{0x3c00000, 0x1, 0xe73a5134, 0x673a5134, 0x3c00080}, +{0x3c00000, 0x1, 0x7c994e9e, 0xfc994e9e, 0x3c00080}, +{0x3c00000, 0x1, 0x6164bd6c, 0xe164bd6c, 0x3c00080}, +{0x3c00000, 0x1, 0x9503366, 0x89503366, 0x3c00080}, +{0x3c00000, 0x1, 0xbf5a97c9, 0x3f5a97c9, 0x3c00080}, +{0x3c00000, 0x1, 0xe6ff1a14, 0x66ff1a14, 0x3c00080}, +{0x3c00000, 0x1, 0x77f31e2f, 0xf7f31e2f, 0x3c00080}, +{0x3c00000, 0x1, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00080}, +{0x3c00000, 0x1, 0x966320b, 0x8966320b, 0x3c00080}, +{0x3c00000, 0x1, 0xb26bddee, 0x326bddee, 0x3c00080}, +{0x3c00000, 0x1, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00080}, +{0x3c00000, 0x1, 0x317285d3, 0xb17285d3, 0x3c00080}, +{0x3c00000, 0x1, 0x3c9623b1, 0xbc9623b1, 0x3c00080}, +{0x3c00000, 0x1, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00080}, +{0x3c00000, 0x1, 0x7b906a6c, 0xfb906a6c, 0x3c00080}, +{0x3c00000, 0x76, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x76, 0x800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x76, 0x1398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x76, 0xba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x76, 0xba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x76, 0x751f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x76, 0x7f7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x76, 0x7f7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x76, 0x7f800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x76, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x76, 0x80800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x76, 0x80800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x76, 0x81398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x76, 0x8ba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x76, 0x8ba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x76, 0xf51f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x76, 0xff7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x76, 0xff7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x76, 0xff800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x76, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x76, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x76, 0x4f3495cb, 0xcf3495cb, 0x3c00080}, +{0x3c00000, 0x76, 0xe73a5134, 0x673a5134, 0x3c00080}, +{0x3c00000, 0x76, 0x7c994e9e, 0xfc994e9e, 0x3c00080}, +{0x3c00000, 0x76, 0x6164bd6c, 0xe164bd6c, 0x3c00080}, +{0x3c00000, 0x76, 0x9503366, 0x89503366, 0x3c00080}, +{0x3c00000, 0x76, 0xbf5a97c9, 0x3f5a97c9, 0x3c00080}, +{0x3c00000, 0x76, 0xe6ff1a14, 0x66ff1a14, 0x3c00080}, +{0x3c00000, 0x76, 0x77f31e2f, 0xf7f31e2f, 0x3c00080}, +{0x3c00000, 0x76, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00080}, +{0x3c00000, 0x76, 0x966320b, 0x8966320b, 0x3c00080}, +{0x3c00000, 0x76, 0xb26bddee, 0x326bddee, 0x3c00080}, +{0x3c00000, 0x76, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00080}, +{0x3c00000, 0x76, 0x317285d3, 0xb17285d3, 0x3c00080}, +{0x3c00000, 0x76, 0x3c9623b1, 0xbc9623b1, 0x3c00080}, +{0x3c00000, 0x76, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00080}, +{0x3c00000, 0x76, 0x7b906a6c, 0xfb906a6c, 0x3c00080}, +{0x3c00000, 0x2b94, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x2b94, 0x1398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x2b94, 0xba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x2b94, 0xba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x2b94, 0x751f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7f7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7f7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7f800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x80800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x2b94, 0x81398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x2b94, 0x8ba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x2b94, 0x8ba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x2b94, 0xf51f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x2b94, 0xff7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x2b94, 0xff7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x2b94, 0xff800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x2b94, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x2b94, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x2b94, 0x4f3495cb, 0xcf3495cb, 0x3c00080}, +{0x3c00000, 0x2b94, 0xe73a5134, 0x673a5134, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7c994e9e, 0xfc994e9e, 0x3c00080}, +{0x3c00000, 0x2b94, 0x6164bd6c, 0xe164bd6c, 0x3c00080}, +{0x3c00000, 0x2b94, 0x9503366, 0x89503366, 0x3c00080}, +{0x3c00000, 0x2b94, 0xbf5a97c9, 0x3f5a97c9, 0x3c00080}, +{0x3c00000, 0x2b94, 0xe6ff1a14, 0x66ff1a14, 0x3c00080}, +{0x3c00000, 0x2b94, 0x77f31e2f, 0xf7f31e2f, 0x3c00080}, +{0x3c00000, 0x2b94, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00080}, +{0x3c00000, 0x2b94, 0x966320b, 0x8966320b, 0x3c00080}, +{0x3c00000, 0x2b94, 0xb26bddee, 0x326bddee, 0x3c00080}, +{0x3c00000, 0x2b94, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00080}, +{0x3c00000, 0x2b94, 0x317285d3, 0xb17285d3, 0x3c00080}, +{0x3c00000, 0x2b94, 0x3c9623b1, 0xbc9623b1, 0x3c00080}, +{0x3c00000, 0x2b94, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00080}, +{0x3c00000, 0x2b94, 0x7b906a6c, 0xfb906a6c, 0x3c00080}, +{0x3c00000, 0x636d24, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x636d24, 0x1398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x636d24, 0xba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x636d24, 0xba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x636d24, 0x751f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7f7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7f7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7f800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x80800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x636d24, 0x81398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x636d24, 0x8ba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x636d24, 0x8ba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x636d24, 0xf51f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x636d24, 0xff7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x636d24, 0xff7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x636d24, 0xff800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x636d24, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x636d24, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x636d24, 0x4f3495cb, 0xcf3495cb, 0x3c00080}, +{0x3c00000, 0x636d24, 0xe73a5134, 0x673a5134, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7c994e9e, 0xfc994e9e, 0x3c00080}, +{0x3c00000, 0x636d24, 0x6164bd6c, 0xe164bd6c, 0x3c00080}, +{0x3c00000, 0x636d24, 0x9503366, 0x89503366, 0x3c00080}, +{0x3c00000, 0x636d24, 0xbf5a97c9, 0x3f5a97c9, 0x3c00080}, +{0x3c00000, 0x636d24, 0xe6ff1a14, 0x66ff1a14, 0x3c00080}, +{0x3c00000, 0x636d24, 0x77f31e2f, 0xf7f31e2f, 0x3c00080}, +{0x3c00000, 0x636d24, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00080}, +{0x3c00000, 0x636d24, 0x966320b, 0x8966320b, 0x3c00080}, +{0x3c00000, 0x636d24, 0xb26bddee, 0x326bddee, 0x3c00080}, +{0x3c00000, 0x636d24, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00080}, +{0x3c00000, 0x636d24, 0x317285d3, 0xb17285d3, 0x3c00080}, +{0x3c00000, 0x636d24, 0x3c9623b1, 0xbc9623b1, 0x3c00080}, +{0x3c00000, 0x636d24, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00080}, +{0x3c00000, 0x636d24, 0x7b906a6c, 0xfb906a6c, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x1398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x751f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7f7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7f7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7f800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x80800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x81398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x8ba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x8ba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xf51f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xff7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xff7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xff800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fffff, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x4f3495cb, 0xcf3495cb, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xe73a5134, 0x673a5134, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7c994e9e, 0xfc994e9e, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x6164bd6c, 0xe164bd6c, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x9503366, 0x89503366, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xbf5a97c9, 0x3f5a97c9, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xe6ff1a14, 0x66ff1a14, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x77f31e2f, 0xf7f31e2f, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x966320b, 0x8966320b, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xb26bddee, 0x326bddee, 0x3c00080}, +{0x3c00000, 0x7fffff, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x317285d3, 0xb17285d3, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x3c9623b1, 0xbc9623b1, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00080}, +{0x3c00000, 0x7fffff, 0x7b906a6c, 0xfb906a6c, 0x3c00080}, +{0x3c00000, 0x800000, 0x0, 0x800000, 0x3c00000}, +{0x3c00000, 0x800000, 0x1, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x76, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x2b94, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x636d24, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x7fffff, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x800000, 0x0, 0x3c00000}, +{0x3c00000, 0x800000, 0x800002, 0x0, 0x3c00008}, +{0x3c00000, 0x800000, 0x1398437, 0x80f3086e, 0x3c00000}, +{0x3c00000, 0x800000, 0xba98d27, 0x8ba98d25, 0x3c00000}, +{0x3c00000, 0x800000, 0xba98d7a, 0x8ba98d78, 0x3c00000}, +{0x3c00000, 0x800000, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x800000, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x800000, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x800000, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x800000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0x80000000, 0x800000, 0x3c00000}, +{0x3c00000, 0x800000, 0x80000001, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x80000076, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x80002b94, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x80636d24, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x807fffff, 0x800000, 0x3c00080}, +{0x3c00000, 0x800000, 0x80800000, 0x1000000, 0x3c00000}, +{0x3c00000, 0x800000, 0x80800002, 0x1000001, 0x3c00000}, +{0x3c00000, 0x800000, 0x81398437, 0x1798437, 0x3c00000}, +{0x3c00000, 0x800000, 0x8ba98d27, 0xba98d29, 0x3c00000}, +{0x3c00000, 0x800000, 0x8ba98d7a, 0xba98d7c, 0x3c00000}, +{0x3c00000, 0x800000, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x800000, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x800000, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x800000, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x800000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800000, 0x4f3495cb, 0xcf3495ca, 0x3c00010}, +{0x3c00000, 0x800000, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0x800000, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0x800000, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0x800000, 0x9503366, 0x89503326, 0x3c00000}, +{0x3c00000, 0x800000, 0xbf5a97c9, 0x3f5a97c9, 0x3c00010}, +{0x3c00000, 0x800000, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0x800000, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0x800000, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00010}, +{0x3c00000, 0x800000, 0x966320b, 0x896631cb, 0x3c00000}, +{0x3c00000, 0x800000, 0xb26bddee, 0x326bddee, 0x3c00010}, +{0x3c00000, 0x800000, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00010}, +{0x3c00000, 0x800000, 0x317285d3, 0xb17285d2, 0x3c00010}, +{0x3c00000, 0x800000, 0x3c9623b1, 0xbc9623b0, 0x3c00010}, +{0x3c00000, 0x800000, 0x51fd2c7c, 0xd1fd2c7b, 0x3c00010}, +{0x3c00000, 0x800000, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0x800002, 0x0, 0x800002, 0x3c00000}, +{0x3c00000, 0x800002, 0x1, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x76, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x2b94, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x636d24, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x7fffff, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x800000, 0x0, 0x3c00008}, +{0x3c00000, 0x800002, 0x800002, 0x0, 0x3c00000}, +{0x3c00000, 0x800002, 0x1398437, 0x80f3086c, 0x3c00000}, +{0x3c00000, 0x800002, 0xba98d27, 0x8ba98d24, 0x3c00010}, +{0x3c00000, 0x800002, 0xba98d7a, 0x8ba98d77, 0x3c00010}, +{0x3c00000, 0x800002, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x800002, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x800002, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x800002, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x800002, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0x80000000, 0x800002, 0x3c00000}, +{0x3c00000, 0x800002, 0x80000001, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x80000076, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x80002b94, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x80636d24, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x807fffff, 0x800002, 0x3c00080}, +{0x3c00000, 0x800002, 0x80800000, 0x1000001, 0x3c00000}, +{0x3c00000, 0x800002, 0x80800002, 0x1000002, 0x3c00000}, +{0x3c00000, 0x800002, 0x81398437, 0x1798438, 0x3c00000}, +{0x3c00000, 0x800002, 0x8ba98d27, 0xba98d29, 0x3c00010}, +{0x3c00000, 0x800002, 0x8ba98d7a, 0xba98d7c, 0x3c00010}, +{0x3c00000, 0x800002, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x800002, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x800002, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x800002, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x800002, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x800002, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x800002, 0x4f3495cb, 0xcf3495ca, 0x3c00010}, +{0x3c00000, 0x800002, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0x800002, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0x800002, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0x800002, 0x9503366, 0x89503325, 0x3c00010}, +{0x3c00000, 0x800002, 0xbf5a97c9, 0x3f5a97c9, 0x3c00010}, +{0x3c00000, 0x800002, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0x800002, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0x800002, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00010}, +{0x3c00000, 0x800002, 0x966320b, 0x896631ca, 0x3c00010}, +{0x3c00000, 0x800002, 0xb26bddee, 0x326bddee, 0x3c00010}, +{0x3c00000, 0x800002, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00010}, +{0x3c00000, 0x800002, 0x317285d3, 0xb17285d2, 0x3c00010}, +{0x3c00000, 0x800002, 0x3c9623b1, 0xbc9623b0, 0x3c00010}, +{0x3c00000, 0x800002, 0x51fd2c7c, 0xd1fd2c7b, 0x3c00010}, +{0x3c00000, 0x800002, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0x1398437, 0x0, 0x1398437, 0x3c00000}, +{0x3c00000, 0x1398437, 0x1, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x76, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x2b94, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x636d24, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x7fffff, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x800000, 0xf3086e, 0x3c00000}, +{0x3c00000, 0x1398437, 0x800002, 0xf3086c, 0x3c00000}, +{0x3c00000, 0x1398437, 0x1398437, 0x0, 0x3c00000}, +{0x3c00000, 0x1398437, 0xba98d27, 0x8ba98d21, 0x3c00010}, +{0x3c00000, 0x1398437, 0xba98d7a, 0x8ba98d74, 0x3c00010}, +{0x3c00000, 0x1398437, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x1398437, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x1398437, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x1398437, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x1398437, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0x80000000, 0x1398437, 0x3c00000}, +{0x3c00000, 0x1398437, 0x80000001, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x80000076, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x80002b94, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x80636d24, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x807fffff, 0x1398437, 0x3c00080}, +{0x3c00000, 0x1398437, 0x80800000, 0x1798437, 0x3c00000}, +{0x3c00000, 0x1398437, 0x80800002, 0x1798438, 0x3c00000}, +{0x3c00000, 0x1398437, 0x81398437, 0x1b98437, 0x3c00000}, +{0x3c00000, 0x1398437, 0x8ba98d27, 0xba98d2c, 0x3c00010}, +{0x3c00000, 0x1398437, 0x8ba98d7a, 0xba98d7f, 0x3c00010}, +{0x3c00000, 0x1398437, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x1398437, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x1398437, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x1398437, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x1398437, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x1398437, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x1398437, 0x4f3495cb, 0xcf3495ca, 0x3c00010}, +{0x3c00000, 0x1398437, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0x1398437, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0x1398437, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0x1398437, 0x9503366, 0x895032ac, 0x3c00010}, +{0x3c00000, 0x1398437, 0xbf5a97c9, 0x3f5a97c9, 0x3c00010}, +{0x3c00000, 0x1398437, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0x1398437, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0x1398437, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00010}, +{0x3c00000, 0x1398437, 0x966320b, 0x89663151, 0x3c00010}, +{0x3c00000, 0x1398437, 0xb26bddee, 0x326bddee, 0x3c00010}, +{0x3c00000, 0x1398437, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00010}, +{0x3c00000, 0x1398437, 0x317285d3, 0xb17285d2, 0x3c00010}, +{0x3c00000, 0x1398437, 0x3c9623b1, 0xbc9623b0, 0x3c00010}, +{0x3c00000, 0x1398437, 0x51fd2c7c, 0xd1fd2c7b, 0x3c00010}, +{0x3c00000, 0x1398437, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x0, 0xba98d27, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x1, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x76, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x2b94, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x636d24, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x7fffff, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x800000, 0xba98d25, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x800002, 0xba98d24, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x1398437, 0xba98d21, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xba98d27, 0x0, 0x3c00000}, +{0x3c00000, 0xba98d27, 0xba98d7a, 0x83260000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x80000000, 0xba98d27, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x80000001, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x80000076, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x80002b94, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x80636d24, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x807fffff, 0xba98d27, 0x3c00080}, +{0x3c00000, 0xba98d27, 0x80800000, 0xba98d29, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x80800002, 0xba98d29, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x81398437, 0xba98d2c, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x8ba98d27, 0xc298d27, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x8ba98d7a, 0xc298d50, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d27, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d27, 0x4f3495cb, 0xcf3495ca, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x9503366, 0xba30b8b, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xbf5a97c9, 0x3f5a97c9, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x966320b, 0xba25b96, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xb26bddee, 0x326bddee, 0x3c00010}, +{0x3c00000, 0xba98d27, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x317285d3, 0xb17285d2, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x3c9623b1, 0xbc9623b0, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x51fd2c7c, 0xd1fd2c7b, 0x3c00010}, +{0x3c00000, 0xba98d27, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x0, 0xba98d7a, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x1, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x76, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x2b94, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x636d24, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x7fffff, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x800000, 0xba98d78, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x800002, 0xba98d77, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x1398437, 0xba98d74, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xba98d27, 0x3260000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0xba98d7a, 0x0, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x80000000, 0xba98d7a, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x80000001, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x80000076, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x80002b94, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x80636d24, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x807fffff, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0xba98d7a, 0x80800000, 0xba98d7c, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x80800002, 0xba98d7c, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x81398437, 0xba98d7f, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x8ba98d27, 0xc298d50, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x8ba98d7a, 0xc298d7a, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xba98d7a, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xba98d7a, 0x4f3495cb, 0xcf3495ca, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x9503366, 0xba30bde, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xbf5a97c9, 0x3f5a97c9, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x966320b, 0xba25be9, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xb26bddee, 0x326bddee, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x317285d3, 0xb17285d2, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x3c9623b1, 0xbc9623b0, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x51fd2c7c, 0xd1fd2c7b, 0x3c00010}, +{0x3c00000, 0xba98d7a, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x0, 0x751f853a, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x1, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x76, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x2b94, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x636d24, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x7fffff, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x800000, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x800002, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x1398437, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xba98d27, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xba98d7a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x751f853a, 0x0, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x7f7ffff0, 0xff7fffe6, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x7f7fffff, 0xff7ffff5, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x80000000, 0x751f853a, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x80000001, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x80000076, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x80002b94, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x80636d24, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x807fffff, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x751f853a, 0x80800000, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x80800002, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x81398437, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x8ba98d27, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x8ba98d7a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xf51f853a, 0x759f853a, 0x3c00000}, +{0x3c00000, 0x751f853a, 0xff7ffff0, 0x7f7ffff9, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xff7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x751f853a, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x751f853a, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x751f853a, 0x4f3495cb, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xe73a5134, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x7c994e9e, 0xfc994d5e, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x6164bd6c, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x9503366, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xbf5a97c9, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xe6ff1a14, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x77f31e2f, 0xf7ee2205, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xaab4d7d8, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x966320b, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xb26bddee, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0xb5c8e5d3, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x317285d3, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x3c9623b1, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x51fd2c7c, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x751f853a, 0x7b906a6c, 0xfb90656f, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x0, 0x7f7ffff0, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x1, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x76, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x2b94, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x636d24, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x7fffff, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x800000, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x800002, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x1398437, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xba98d27, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xba98d7a, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x751f853a, 0x7f7fffe6, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x7f7ffff0, 0x0, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x7f7fffff, 0xf5700000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x80000000, 0x7f7ffff0, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x80000001, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x80000076, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x80002b94, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x80636d24, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x807fffff, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x7f7ffff0, 0x80800000, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x80800002, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x81398437, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x8ba98d27, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x8ba98d7a, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xf51f853a, 0x7f7ffff9, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xff7ffff0, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7ffff0, 0xff7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7ffff0, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7ffff0, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7ffff0, 0x4f3495cb, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xe73a5134, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x7c994e9e, 0x7f7b357b, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x6164bd6c, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x9503366, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xbf5a97c9, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xe6ff1a14, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x77f31e2f, 0x7f7ffe09, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xaab4d7d8, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x966320b, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xb26bddee, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0xb5c8e5d3, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x317285d3, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x3c9623b1, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x51fd2c7c, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x7f7ffff0, 0x7b906a6c, 0x7f7edf1b, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x0, 0x7f7fffff, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x1, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x76, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x2b94, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x636d24, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x800000, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x800002, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x1398437, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xba98d27, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xba98d7a, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x751f853a, 0x7f7ffff5, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x7f7ffff0, 0x75700000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x7f7fffff, 0x0, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x80000000, 0x7f7fffff, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x80000001, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x80000076, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x80002b94, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x80636d24, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x807fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x7f7fffff, 0x80800000, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x80800002, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x81398437, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x8ba98d27, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x8ba98d7a, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xf51f853a, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7fffff, 0xff7ffff0, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7fffff, 0xff7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7f7fffff, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f7fffff, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f7fffff, 0x4f3495cb, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xe73a5134, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x7c994e9e, 0x7f7b358a, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x6164bd6c, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x9503366, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xbf5a97c9, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xe6ff1a14, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x77f31e2f, 0x7f7ffe18, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xaab4d7d8, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x966320b, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xb26bddee, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0xb5c8e5d3, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x317285d3, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x3c9623b1, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x51fd2c7c, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x7f7fffff, 0x7b906a6c, 0x7f7edf2a, 0x3c00010}, +{0x3c00000, 0x7f800000, 0x0, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x1, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x76, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x2b94, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x636d24, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x7fffff, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x800002, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x1398437, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xba98d27, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xba98d7a, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x751f853a, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7f7ffff0, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7f7fffff, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x80000000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x80000001, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x80000076, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x80002b94, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x80636d24, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x807fffff, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x7f800000, 0x80800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x80800002, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x81398437, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x8ba98d27, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x8ba98d7a, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xf51f853a, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xff7ffff0, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xff7fffff, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x4f3495cb, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xe73a5134, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7c994e9e, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x6164bd6c, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x9503366, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xbf5a97c9, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xe6ff1a14, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x77f31e2f, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xaab4d7d8, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x966320b, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xb26bddee, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0xb5c8e5d3, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x317285d3, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x3c9623b1, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x51fd2c7c, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800000, 0x7b906a6c, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7f800001, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f800001, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f800001, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7f984a37, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7f984a37, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x7fbfffff, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fbfffff, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fc00000, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fc00000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fc00000, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fd9ba98, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fd9ba98, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fd9ba98, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x7fffffff, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7fffffff, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7fffffff, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x0, 0x80000000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x1, 0x80000000, 0x3c00080}, +{0x3c00000, 0x80000000, 0x76, 0x80000000, 0x3c00080}, +{0x3c00000, 0x80000000, 0x2b94, 0x80000000, 0x3c00080}, +{0x3c00000, 0x80000000, 0x636d24, 0x80000000, 0x3c00080}, +{0x3c00000, 0x80000000, 0x7fffff, 0x80000000, 0x3c00080}, +{0x3c00000, 0x80000000, 0x800000, 0x80800000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x800002, 0x80800002, 0x3c00000}, +{0x3c00000, 0x80000000, 0x1398437, 0x81398437, 0x3c00000}, +{0x3c00000, 0x80000000, 0xba98d27, 0x8ba98d27, 0x3c00000}, +{0x3c00000, 0x80000000, 0xba98d7a, 0x8ba98d7a, 0x3c00000}, +{0x3c00000, 0x80000000, 0x751f853a, 0xf51f853a, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7f7ffff0, 0xff7ffff0, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7f7fffff, 0xff7fffff, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x80000000, 0x0, 0x3c00000}, +{0x3c00000, 0x80000000, 0x80000001, 0x80000000, 0x3c00080}, +{0x3c00000, 0x80000000, 0x80000076, 0x80000000, 0x3c00080}, +{0x3c00000, 0x80000000, 0x80002b94, 0x80000000, 0x3c00080}, +{0x3c00000, 0x80000000, 0x80636d24, 0x80000000, 0x3c00080}, +{0x3c00000, 0x80000000, 0x807fffff, 0x80000000, 0x3c00080}, +{0x3c00000, 0x80000000, 0x80800000, 0x800000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x80800002, 0x800002, 0x3c00000}, +{0x3c00000, 0x80000000, 0x81398437, 0x1398437, 0x3c00000}, +{0x3c00000, 0x80000000, 0x8ba98d27, 0xba98d27, 0x3c00000}, +{0x3c00000, 0x80000000, 0x8ba98d7a, 0xba98d7a, 0x3c00000}, +{0x3c00000, 0x80000000, 0xf51f853a, 0x751f853a, 0x3c00000}, +{0x3c00000, 0x80000000, 0xff7ffff0, 0x7f7ffff0, 0x3c00000}, +{0x3c00000, 0x80000000, 0xff7fffff, 0x7f7fffff, 0x3c00000}, +{0x3c00000, 0x80000000, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x80000000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80000000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80000000, 0x4f3495cb, 0xcf3495cb, 0x3c00000}, +{0x3c00000, 0x80000000, 0xe73a5134, 0x673a5134, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7c994e9e, 0xfc994e9e, 0x3c00000}, +{0x3c00000, 0x80000000, 0x6164bd6c, 0xe164bd6c, 0x3c00000}, +{0x3c00000, 0x80000000, 0x9503366, 0x89503366, 0x3c00000}, +{0x3c00000, 0x80000000, 0xbf5a97c9, 0x3f5a97c9, 0x3c00000}, +{0x3c00000, 0x80000000, 0xe6ff1a14, 0x66ff1a14, 0x3c00000}, +{0x3c00000, 0x80000000, 0x77f31e2f, 0xf7f31e2f, 0x3c00000}, +{0x3c00000, 0x80000000, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00000}, +{0x3c00000, 0x80000000, 0x966320b, 0x8966320b, 0x3c00000}, +{0x3c00000, 0x80000000, 0xb26bddee, 0x326bddee, 0x3c00000}, +{0x3c00000, 0x80000000, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00000}, +{0x3c00000, 0x80000000, 0x317285d3, 0xb17285d3, 0x3c00000}, +{0x3c00000, 0x80000000, 0x3c9623b1, 0xbc9623b1, 0x3c00000}, +{0x3c00000, 0x80000000, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00000}, +{0x3c00000, 0x80000000, 0x7b906a6c, 0xfb906a6c, 0x3c00000}, +{0x3c00000, 0x80000001, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80000001, 0x1398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x80000001, 0xba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x80000001, 0xba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x80000001, 0x751f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7f7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7f7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7f800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x80800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x80000001, 0x81398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x80000001, 0x8ba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x80000001, 0x8ba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x80000001, 0xf51f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x80000001, 0xff7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x80000001, 0xff7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x80000001, 0xff800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x80000001, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000001, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000001, 0x4f3495cb, 0xcf3495cb, 0x3c00080}, +{0x3c00000, 0x80000001, 0xe73a5134, 0x673a5134, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7c994e9e, 0xfc994e9e, 0x3c00080}, +{0x3c00000, 0x80000001, 0x6164bd6c, 0xe164bd6c, 0x3c00080}, +{0x3c00000, 0x80000001, 0x9503366, 0x89503366, 0x3c00080}, +{0x3c00000, 0x80000001, 0xbf5a97c9, 0x3f5a97c9, 0x3c00080}, +{0x3c00000, 0x80000001, 0xe6ff1a14, 0x66ff1a14, 0x3c00080}, +{0x3c00000, 0x80000001, 0x77f31e2f, 0xf7f31e2f, 0x3c00080}, +{0x3c00000, 0x80000001, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00080}, +{0x3c00000, 0x80000001, 0x966320b, 0x8966320b, 0x3c00080}, +{0x3c00000, 0x80000001, 0xb26bddee, 0x326bddee, 0x3c00080}, +{0x3c00000, 0x80000001, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00080}, +{0x3c00000, 0x80000001, 0x317285d3, 0xb17285d3, 0x3c00080}, +{0x3c00000, 0x80000001, 0x3c9623b1, 0xbc9623b1, 0x3c00080}, +{0x3c00000, 0x80000001, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00080}, +{0x3c00000, 0x80000001, 0x7b906a6c, 0xfb906a6c, 0x3c00080}, +{0x3c00000, 0x80000076, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80000076, 0x1398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x80000076, 0xba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x80000076, 0xba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x80000076, 0x751f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7f7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7f7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7f800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x80800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x80000076, 0x81398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x80000076, 0x8ba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x80000076, 0x8ba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x80000076, 0xf51f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x80000076, 0xff7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x80000076, 0xff7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x80000076, 0xff800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x80000076, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80000076, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80000076, 0x4f3495cb, 0xcf3495cb, 0x3c00080}, +{0x3c00000, 0x80000076, 0xe73a5134, 0x673a5134, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7c994e9e, 0xfc994e9e, 0x3c00080}, +{0x3c00000, 0x80000076, 0x6164bd6c, 0xe164bd6c, 0x3c00080}, +{0x3c00000, 0x80000076, 0x9503366, 0x89503366, 0x3c00080}, +{0x3c00000, 0x80000076, 0xbf5a97c9, 0x3f5a97c9, 0x3c00080}, +{0x3c00000, 0x80000076, 0xe6ff1a14, 0x66ff1a14, 0x3c00080}, +{0x3c00000, 0x80000076, 0x77f31e2f, 0xf7f31e2f, 0x3c00080}, +{0x3c00000, 0x80000076, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00080}, +{0x3c00000, 0x80000076, 0x966320b, 0x8966320b, 0x3c00080}, +{0x3c00000, 0x80000076, 0xb26bddee, 0x326bddee, 0x3c00080}, +{0x3c00000, 0x80000076, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00080}, +{0x3c00000, 0x80000076, 0x317285d3, 0xb17285d3, 0x3c00080}, +{0x3c00000, 0x80000076, 0x3c9623b1, 0xbc9623b1, 0x3c00080}, +{0x3c00000, 0x80000076, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00080}, +{0x3c00000, 0x80000076, 0x7b906a6c, 0xfb906a6c, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x1398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x751f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7f7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7f7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7f800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x80800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x81398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x8ba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x8ba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xf51f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xff7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xff7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xff800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80002b94, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x4f3495cb, 0xcf3495cb, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xe73a5134, 0x673a5134, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7c994e9e, 0xfc994e9e, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x6164bd6c, 0xe164bd6c, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x9503366, 0x89503366, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xbf5a97c9, 0x3f5a97c9, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xe6ff1a14, 0x66ff1a14, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x77f31e2f, 0xf7f31e2f, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x966320b, 0x8966320b, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xb26bddee, 0x326bddee, 0x3c00080}, +{0x3c00000, 0x80002b94, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x317285d3, 0xb17285d3, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x3c9623b1, 0xbc9623b1, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00080}, +{0x3c00000, 0x80002b94, 0x7b906a6c, 0xfb906a6c, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x1398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x751f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7f7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7f7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7f800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x80800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x81398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x8ba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x8ba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xf51f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xff7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xff7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xff800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x80636d24, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x4f3495cb, 0xcf3495cb, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xe73a5134, 0x673a5134, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7c994e9e, 0xfc994e9e, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x6164bd6c, 0xe164bd6c, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x9503366, 0x89503366, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xbf5a97c9, 0x3f5a97c9, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xe6ff1a14, 0x66ff1a14, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x77f31e2f, 0xf7f31e2f, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x966320b, 0x8966320b, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xb26bddee, 0x326bddee, 0x3c00080}, +{0x3c00000, 0x80636d24, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x317285d3, 0xb17285d3, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x3c9623b1, 0xbc9623b1, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00080}, +{0x3c00000, 0x80636d24, 0x7b906a6c, 0xfb906a6c, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x0, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x1, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x76, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x2b94, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x800000, 0x80800000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x800002, 0x80800002, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x1398437, 0x81398437, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xba98d27, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xba98d7a, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x751f853a, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7f7ffff0, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7f7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7f800000, 0xff800000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7f800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0x7f984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0x7fbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0x7fc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7fd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7fffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80000000, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80000001, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80000076, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80002b94, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80636d24, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x807fffff, 0x0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80800000, 0x800000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x80800002, 0x800002, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x81398437, 0x1398437, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x8ba98d27, 0xba98d27, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x8ba98d7a, 0xba98d7a, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xf51f853a, 0x751f853a, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xff7ffff0, 0x7f7ffff0, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xff7fffff, 0x7f7fffff, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xff800000, 0x7f800000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xff800001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0xff984a37, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0xffbfffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0x807fffff, 0xffc00000, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xffd9ba98, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xffffffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x4f3495cb, 0xcf3495cb, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xe73a5134, 0x673a5134, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7c994e9e, 0xfc994e9e, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x6164bd6c, 0xe164bd6c, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x9503366, 0x89503366, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xbf5a97c9, 0x3f5a97c9, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xe6ff1a14, 0x66ff1a14, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x77f31e2f, 0xf7f31e2f, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x966320b, 0x8966320b, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xb26bddee, 0x326bddee, 0x3c00080}, +{0x3c00000, 0x807fffff, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x317285d3, 0xb17285d3, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x3c9623b1, 0xbc9623b1, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00080}, +{0x3c00000, 0x807fffff, 0x7b906a6c, 0xfb906a6c, 0x3c00080}, +{0x3c00000, 0x80800000, 0x0, 0x80800000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x1, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x76, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x2b94, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x636d24, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x7fffff, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x800000, 0x81000000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x800002, 0x81000001, 0x3c00000}, +{0x3c00000, 0x80800000, 0x1398437, 0x81798437, 0x3c00000}, +{0x3c00000, 0x80800000, 0xba98d27, 0x8ba98d29, 0x3c00000}, +{0x3c00000, 0x80800000, 0xba98d7a, 0x8ba98d7c, 0x3c00000}, +{0x3c00000, 0x80800000, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0x80800000, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0x80800000, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0x80800000, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x80000000, 0x80800000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x80000001, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x80000076, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x80002b94, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x80636d24, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x807fffff, 0x80800000, 0x3c00080}, +{0x3c00000, 0x80800000, 0x80800000, 0x0, 0x3c00000}, +{0x3c00000, 0x80800000, 0x80800002, 0x0, 0x3c00008}, +{0x3c00000, 0x80800000, 0x81398437, 0xf3086e, 0x3c00000}, +{0x3c00000, 0x80800000, 0x8ba98d27, 0xba98d25, 0x3c00000}, +{0x3c00000, 0x80800000, 0x8ba98d7a, 0xba98d78, 0x3c00000}, +{0x3c00000, 0x80800000, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x80800000, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x80800000, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x80800000, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x80800000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800000, 0x4f3495cb, 0xcf3495cb, 0x3c00010}, +{0x3c00000, 0x80800000, 0xe73a5134, 0x673a5133, 0x3c00010}, +{0x3c00000, 0x80800000, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0x80800000, 0x6164bd6c, 0xe164bd6c, 0x3c00010}, +{0x3c00000, 0x80800000, 0x9503366, 0x895033a6, 0x3c00000}, +{0x3c00000, 0x80800000, 0xbf5a97c9, 0x3f5a97c8, 0x3c00010}, +{0x3c00000, 0x80800000, 0xe6ff1a14, 0x66ff1a13, 0x3c00010}, +{0x3c00000, 0x80800000, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0x80800000, 0xaab4d7d8, 0x2ab4d7d7, 0x3c00010}, +{0x3c00000, 0x80800000, 0x966320b, 0x8966324b, 0x3c00000}, +{0x3c00000, 0x80800000, 0xb26bddee, 0x326bdded, 0x3c00010}, +{0x3c00000, 0x80800000, 0xb5c8e5d3, 0x35c8e5d2, 0x3c00010}, +{0x3c00000, 0x80800000, 0x317285d3, 0xb17285d3, 0x3c00010}, +{0x3c00000, 0x80800000, 0x3c9623b1, 0xbc9623b1, 0x3c00010}, +{0x3c00000, 0x80800000, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00010}, +{0x3c00000, 0x80800000, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0x80800002, 0x0, 0x80800002, 0x3c00000}, +{0x3c00000, 0x80800002, 0x1, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x76, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x2b94, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x636d24, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x7fffff, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x800000, 0x81000001, 0x3c00000}, +{0x3c00000, 0x80800002, 0x800002, 0x81000002, 0x3c00000}, +{0x3c00000, 0x80800002, 0x1398437, 0x81798438, 0x3c00000}, +{0x3c00000, 0x80800002, 0xba98d27, 0x8ba98d29, 0x3c00010}, +{0x3c00000, 0x80800002, 0xba98d7a, 0x8ba98d7c, 0x3c00010}, +{0x3c00000, 0x80800002, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0x80800002, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0x80800002, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0x80800002, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x80800002, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0x80000000, 0x80800002, 0x3c00000}, +{0x3c00000, 0x80800002, 0x80000001, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x80000076, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x80002b94, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x80636d24, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x807fffff, 0x80800002, 0x3c00080}, +{0x3c00000, 0x80800002, 0x80800000, 0x0, 0x3c00008}, +{0x3c00000, 0x80800002, 0x80800002, 0x0, 0x3c00000}, +{0x3c00000, 0x80800002, 0x81398437, 0xf3086c, 0x3c00000}, +{0x3c00000, 0x80800002, 0x8ba98d27, 0xba98d24, 0x3c00010}, +{0x3c00000, 0x80800002, 0x8ba98d7a, 0xba98d77, 0x3c00010}, +{0x3c00000, 0x80800002, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x80800002, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x80800002, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x80800002, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x80800002, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x80800002, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x80800002, 0x4f3495cb, 0xcf3495cb, 0x3c00010}, +{0x3c00000, 0x80800002, 0xe73a5134, 0x673a5133, 0x3c00010}, +{0x3c00000, 0x80800002, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0x80800002, 0x6164bd6c, 0xe164bd6c, 0x3c00010}, +{0x3c00000, 0x80800002, 0x9503366, 0x895033a6, 0x3c00010}, +{0x3c00000, 0x80800002, 0xbf5a97c9, 0x3f5a97c8, 0x3c00010}, +{0x3c00000, 0x80800002, 0xe6ff1a14, 0x66ff1a13, 0x3c00010}, +{0x3c00000, 0x80800002, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0x80800002, 0xaab4d7d8, 0x2ab4d7d7, 0x3c00010}, +{0x3c00000, 0x80800002, 0x966320b, 0x8966324b, 0x3c00010}, +{0x3c00000, 0x80800002, 0xb26bddee, 0x326bdded, 0x3c00010}, +{0x3c00000, 0x80800002, 0xb5c8e5d3, 0x35c8e5d2, 0x3c00010}, +{0x3c00000, 0x80800002, 0x317285d3, 0xb17285d3, 0x3c00010}, +{0x3c00000, 0x80800002, 0x3c9623b1, 0xbc9623b1, 0x3c00010}, +{0x3c00000, 0x80800002, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00010}, +{0x3c00000, 0x80800002, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0x81398437, 0x0, 0x81398437, 0x3c00000}, +{0x3c00000, 0x81398437, 0x1, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x76, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x2b94, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x636d24, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x7fffff, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x800000, 0x81798437, 0x3c00000}, +{0x3c00000, 0x81398437, 0x800002, 0x81798438, 0x3c00000}, +{0x3c00000, 0x81398437, 0x1398437, 0x81b98437, 0x3c00000}, +{0x3c00000, 0x81398437, 0xba98d27, 0x8ba98d2c, 0x3c00010}, +{0x3c00000, 0x81398437, 0xba98d7a, 0x8ba98d7f, 0x3c00010}, +{0x3c00000, 0x81398437, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0x81398437, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0x81398437, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0x81398437, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x81398437, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0x80000000, 0x81398437, 0x3c00000}, +{0x3c00000, 0x81398437, 0x80000001, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x80000076, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x80002b94, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x80636d24, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x807fffff, 0x81398437, 0x3c00080}, +{0x3c00000, 0x81398437, 0x80800000, 0x80f3086e, 0x3c00000}, +{0x3c00000, 0x81398437, 0x80800002, 0x80f3086c, 0x3c00000}, +{0x3c00000, 0x81398437, 0x81398437, 0x0, 0x3c00000}, +{0x3c00000, 0x81398437, 0x8ba98d27, 0xba98d21, 0x3c00010}, +{0x3c00000, 0x81398437, 0x8ba98d7a, 0xba98d74, 0x3c00010}, +{0x3c00000, 0x81398437, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x81398437, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x81398437, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x81398437, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x81398437, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x81398437, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x81398437, 0x4f3495cb, 0xcf3495cb, 0x3c00010}, +{0x3c00000, 0x81398437, 0xe73a5134, 0x673a5133, 0x3c00010}, +{0x3c00000, 0x81398437, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0x81398437, 0x6164bd6c, 0xe164bd6c, 0x3c00010}, +{0x3c00000, 0x81398437, 0x9503366, 0x8950341f, 0x3c00010}, +{0x3c00000, 0x81398437, 0xbf5a97c9, 0x3f5a97c8, 0x3c00010}, +{0x3c00000, 0x81398437, 0xe6ff1a14, 0x66ff1a13, 0x3c00010}, +{0x3c00000, 0x81398437, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0x81398437, 0xaab4d7d8, 0x2ab4d7d7, 0x3c00010}, +{0x3c00000, 0x81398437, 0x966320b, 0x896632c4, 0x3c00010}, +{0x3c00000, 0x81398437, 0xb26bddee, 0x326bdded, 0x3c00010}, +{0x3c00000, 0x81398437, 0xb5c8e5d3, 0x35c8e5d2, 0x3c00010}, +{0x3c00000, 0x81398437, 0x317285d3, 0xb17285d3, 0x3c00010}, +{0x3c00000, 0x81398437, 0x3c9623b1, 0xbc9623b1, 0x3c00010}, +{0x3c00000, 0x81398437, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00010}, +{0x3c00000, 0x81398437, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x0, 0x8ba98d27, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x1, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x76, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x2b94, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x636d24, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x7fffff, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x800000, 0x8ba98d29, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x800002, 0x8ba98d29, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x1398437, 0x8ba98d2c, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xba98d27, 0x8c298d27, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0xba98d7a, 0x8c298d50, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x80000000, 0x8ba98d27, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x80000001, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x80000076, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x80002b94, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x80636d24, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x807fffff, 0x8ba98d27, 0x3c00080}, +{0x3c00000, 0x8ba98d27, 0x80800000, 0x8ba98d25, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x80800002, 0x8ba98d24, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x81398437, 0x8ba98d21, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x8ba98d27, 0x0, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x8ba98d7a, 0x3260000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d27, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d27, 0x4f3495cb, 0xcf3495cb, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xe73a5134, 0x673a5133, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x6164bd6c, 0xe164bd6c, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x9503366, 0x8bb00ec2, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xbf5a97c9, 0x3f5a97c8, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xe6ff1a14, 0x66ff1a13, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xaab4d7d8, 0x2ab4d7d7, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x966320b, 0x8bb0beb7, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xb26bddee, 0x326bdded, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0xb5c8e5d3, 0x35c8e5d2, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x317285d3, 0xb17285d3, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x3c9623b1, 0xbc9623b1, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00010}, +{0x3c00000, 0x8ba98d27, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x0, 0x8ba98d7a, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x1, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x76, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x2b94, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x636d24, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x7fffff, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x800000, 0x8ba98d7c, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x800002, 0x8ba98d7c, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x1398437, 0x8ba98d7f, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xba98d27, 0x8c298d50, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xba98d7a, 0x8c298d7a, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x80000000, 0x8ba98d7a, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x80000001, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x80000076, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x80002b94, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x80636d24, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x807fffff, 0x8ba98d7a, 0x3c00080}, +{0x3c00000, 0x8ba98d7a, 0x80800000, 0x8ba98d78, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x80800002, 0x8ba98d77, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x81398437, 0x8ba98d74, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x8ba98d27, 0x83260000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x8ba98d7a, 0x0, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x8ba98d7a, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x8ba98d7a, 0x4f3495cb, 0xcf3495cb, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xe73a5134, 0x673a5133, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x6164bd6c, 0xe164bd6c, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x9503366, 0x8bb00f15, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xbf5a97c9, 0x3f5a97c8, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xe6ff1a14, 0x66ff1a13, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xaab4d7d8, 0x2ab4d7d7, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x966320b, 0x8bb0bf0a, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xb26bddee, 0x326bdded, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0xb5c8e5d3, 0x35c8e5d2, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x317285d3, 0xb17285d3, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x3c9623b1, 0xbc9623b1, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00010}, +{0x3c00000, 0x8ba98d7a, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x0, 0xf51f853a, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x1, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x76, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x2b94, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x636d24, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x7fffff, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x800000, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x800002, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x1398437, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xba98d27, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xba98d7a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x751f853a, 0xf59f853a, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x7f7ffff0, 0xff7ffff9, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x7f7fffff, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xf51f853a, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x80000000, 0xf51f853a, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x80000001, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x80000076, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x80002b94, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x80636d24, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x807fffff, 0xf51f853a, 0x3c00080}, +{0x3c00000, 0xf51f853a, 0x80800000, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x80800002, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x81398437, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x8ba98d27, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x8ba98d7a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xf51f853a, 0x0, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0xff7ffff0, 0x7f7fffe6, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xff7fffff, 0x7f7ffff5, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xf51f853a, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xf51f853a, 0x4f3495cb, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xe73a5134, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x7c994e9e, 0xfc994fdd, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x6164bd6c, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x9503366, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xbf5a97c9, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xe6ff1a14, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x77f31e2f, 0xf7f81a58, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xaab4d7d8, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x966320b, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xb26bddee, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0xb5c8e5d3, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x317285d3, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x3c9623b1, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x51fd2c7c, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xf51f853a, 0x7b906a6c, 0xfb906f68, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x0, 0xff7ffff0, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x1, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x76, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x2b94, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x636d24, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x7fffff, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x800000, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x800002, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x1398437, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xba98d27, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xba98d7a, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x751f853a, 0xff7ffff9, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x7f7ffff0, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7ffff0, 0x7f7fffff, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7ffff0, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x80000000, 0xff7ffff0, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x80000001, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x80000076, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x80002b94, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x80636d24, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x807fffff, 0xff7ffff0, 0x3c00080}, +{0x3c00000, 0xff7ffff0, 0x80800000, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x80800002, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x81398437, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x8ba98d27, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x8ba98d7a, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xf51f853a, 0xff7fffe6, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xff7ffff0, 0x0, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0xff7fffff, 0x75700000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7ffff0, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7ffff0, 0x4f3495cb, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xe73a5134, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x7c994e9e, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7ffff0, 0x6164bd6c, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x9503366, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xbf5a97c9, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xe6ff1a14, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x77f31e2f, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7ffff0, 0xaab4d7d8, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x966320b, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xb26bddee, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0xb5c8e5d3, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x317285d3, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x3c9623b1, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x51fd2c7c, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xff7ffff0, 0x7b906a6c, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7fffff, 0x0, 0xff7fffff, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x1, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x76, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x2b94, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x636d24, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x7fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x800000, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x800002, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x1398437, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xba98d27, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xba98d7a, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x751f853a, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7fffff, 0x7f7ffff0, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7fffff, 0x7f7fffff, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7fffff, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x80000000, 0xff7fffff, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x80000001, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x80000076, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x80002b94, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x80636d24, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x807fffff, 0xff7fffff, 0x3c00080}, +{0x3c00000, 0xff7fffff, 0x80800000, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x80800002, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x81398437, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x8ba98d27, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x8ba98d7a, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xf51f853a, 0xff7ffff5, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xff7ffff0, 0xf5700000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0xff7fffff, 0x0, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff7fffff, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff7fffff, 0x4f3495cb, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xe73a5134, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x7c994e9e, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7fffff, 0x6164bd6c, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x9503366, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xbf5a97c9, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xe6ff1a14, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x77f31e2f, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff7fffff, 0xaab4d7d8, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x966320b, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xb26bddee, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0xb5c8e5d3, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x317285d3, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x3c9623b1, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x51fd2c7c, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xff7fffff, 0x7b906a6c, 0xff7fffff, 0x3c00014}, +{0x3c00000, 0xff800000, 0x0, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x1, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x76, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x2b94, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x636d24, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x7fffff, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x800002, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x1398437, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xba98d27, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xba98d7a, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x751f853a, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7f7ffff0, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7f7fffff, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x80000000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x80000001, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x80000076, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x80002b94, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x80636d24, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x807fffff, 0xff800000, 0x3c00080}, +{0x3c00000, 0xff800000, 0x80800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x80800002, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x81398437, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x8ba98d27, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x8ba98d7a, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xf51f853a, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xff7ffff0, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xff7fffff, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x4f3495cb, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xe73a5134, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7c994e9e, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x6164bd6c, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x9503366, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xbf5a97c9, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xe6ff1a14, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x77f31e2f, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xaab4d7d8, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x966320b, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xb26bddee, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0xb5c8e5d3, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x317285d3, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x3c9623b1, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x51fd2c7c, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800000, 0x7b906a6c, 0xff800000, 0x3c00000}, +{0x3c00000, 0xff800001, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff800001, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff800001, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xff984a37, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xff984a37, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x1, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x76, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x2b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x7fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x1398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x751f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7f7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7f7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7f800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7fc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7fd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7fffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x80000000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x80000001, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x80000076, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x80002b94, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x80636d24, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x807fffff, 0x7fc00000, 0x3c00081}, +{0x3c00000, 0xffbfffff, 0x80800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x80800002, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x81398437, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x8ba98d27, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x8ba98d7a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xf51f853a, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xff7ffff0, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xff7fffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xff800000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xffc00000, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xffd9ba98, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xffffffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x4f3495cb, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xe73a5134, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7c994e9e, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x6164bd6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x9503366, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xbf5a97c9, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xe6ff1a14, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x77f31e2f, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xaab4d7d8, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x966320b, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xb26bddee, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x317285d3, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x3c9623b1, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x51fd2c7c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffbfffff, 0x7b906a6c, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffc00000, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffc00000, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffc00000, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffd9ba98, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffd9ba98, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffd9ba98, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x1, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x76, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x2b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x7fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x1398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x751f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7f7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7f7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7f800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x80000000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x80000001, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x80000076, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x80002b94, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x80636d24, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x807fffff, 0x7fc00000, 0x3c00080}, +{0x3c00000, 0xffffffff, 0x80800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x80800002, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x81398437, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x8ba98d27, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x8ba98d7a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xf51f853a, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xff7ffff0, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xff7fffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xff800000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xffffffff, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x4f3495cb, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xe73a5134, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7c994e9e, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x6164bd6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x9503366, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xbf5a97c9, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xe6ff1a14, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x77f31e2f, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xaab4d7d8, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x966320b, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xb26bddee, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0xb5c8e5d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x317285d3, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x3c9623b1, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x51fd2c7c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xffffffff, 0x7b906a6c, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x0, 0x4f3495cb, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x1, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x76, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x2b94, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x636d24, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x7fffff, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x800000, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x800002, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x1398437, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xba98d27, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xba98d7a, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x80000000, 0x4f3495cb, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x80000001, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x80000076, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x80002b94, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x80636d24, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x807fffff, 0x4f3495cb, 0x3c00080}, +{0x3c00000, 0x4f3495cb, 0x80800000, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x80800002, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x81398437, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x8ba98d27, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x8ba98d7a, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x4f3495cb, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0x4f3495cb, 0x0, 0x3c00000}, +{0x3c00000, 0x4f3495cb, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x9503366, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xbf5a97c9, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xaab4d7d8, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x966320b, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xb26bddee, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0xb5c8e5d3, 0x4f3495cb, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x317285d3, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x3c9623b1, 0x4f3495ca, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x51fd2c7c, 0xd1f787cd, 0x3c00010}, +{0x3c00000, 0x4f3495cb, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x0, 0xe73a5134, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x1, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x76, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x2b94, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x636d24, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x7fffff, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x800000, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x800002, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x1398437, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xba98d27, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xba98d7a, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x80000000, 0xe73a5134, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x80000001, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x80000076, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x80002b94, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x80636d24, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x807fffff, 0xe73a5134, 0x3c00080}, +{0x3c00000, 0xe73a5134, 0x80800000, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x80800002, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x81398437, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x8ba98d27, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x8ba98d7a, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe73a5134, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x4f3495cb, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xe73a5134, 0x0, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x6164bd6c, 0xe73a5f7f, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x9503366, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xbf5a97c9, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xe6ff1a14, 0xe66b10a8, 0x3c00000}, +{0x3c00000, 0xe73a5134, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xaab4d7d8, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x966320b, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xb26bddee, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0xb5c8e5d3, 0xe73a5133, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x317285d3, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x3c9623b1, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x51fd2c7c, 0xe73a5134, 0x3c00010}, +{0x3c00000, 0xe73a5134, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x0, 0x7c994e9e, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x1, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x76, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x2b94, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x636d24, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x7fffff, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x800000, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x800002, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x1398437, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xba98d27, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xba98d7a, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x751f853a, 0x7c994d5e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x7f7ffff0, 0xff7b357b, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x7f7fffff, 0xff7b358a, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x80000000, 0x7c994e9e, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x80000001, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x80000076, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x80002b94, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x80636d24, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x807fffff, 0x7c994e9e, 0x3c00080}, +{0x3c00000, 0x7c994e9e, 0x80800000, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x80800002, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x81398437, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x8ba98d27, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x8ba98d7a, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xf51f853a, 0x7c994fdd, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xff7ffff0, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7c994e9e, 0xff7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7c994e9e, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7c994e9e, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x4f3495cb, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xe73a5134, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x7c994e9e, 0x0, 0x3c00000}, +{0x3c00000, 0x7c994e9e, 0x6164bd6c, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x9503366, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xbf5a97c9, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xe6ff1a14, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x77f31e2f, 0x7c9911d6, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xaab4d7d8, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x966320b, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xb26bddee, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0xb5c8e5d3, 0x7c994e9e, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x317285d3, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x3c9623b1, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x51fd2c7c, 0x7c994e9d, 0x3c00010}, +{0x3c00000, 0x7c994e9e, 0x7b906a6c, 0x7c6a6806, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x0, 0x6164bd6c, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x1, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x76, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x2b94, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x636d24, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x7fffff, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x800000, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x800002, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x1398437, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xba98d27, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xba98d7a, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x80000000, 0x6164bd6c, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x80000001, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x80000076, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x80002b94, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x80636d24, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x807fffff, 0x6164bd6c, 0x3c00080}, +{0x3c00000, 0x6164bd6c, 0x80800000, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x80800002, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x81398437, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x8ba98d27, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x8ba98d7a, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x6164bd6c, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x4f3495cb, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xe73a5134, 0x673a5f7f, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x6164bd6c, 0x0, 0x3c00000}, +{0x3c00000, 0x6164bd6c, 0x9503366, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xbf5a97c9, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xe6ff1a14, 0x66ff36ab, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xaab4d7d8, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x966320b, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xb26bddee, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0xb5c8e5d3, 0x6164bd6c, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x317285d3, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x3c9623b1, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x51fd2c7c, 0x6164bd6b, 0x3c00010}, +{0x3c00000, 0x6164bd6c, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0x9503366, 0x0, 0x9503366, 0x3c00000}, +{0x3c00000, 0x9503366, 0x1, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x76, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x2b94, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x636d24, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x7fffff, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x800000, 0x9503326, 0x3c00000}, +{0x3c00000, 0x9503366, 0x800002, 0x9503325, 0x3c00010}, +{0x3c00000, 0x9503366, 0x1398437, 0x95032ac, 0x3c00010}, +{0x3c00000, 0x9503366, 0xba98d27, 0x8ba30b8b, 0x3c00010}, +{0x3c00000, 0x9503366, 0xba98d7a, 0x8ba30bde, 0x3c00010}, +{0x3c00000, 0x9503366, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x9503366, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x9503366, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x9503366, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x9503366, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0x80000000, 0x9503366, 0x3c00000}, +{0x3c00000, 0x9503366, 0x80000001, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x80000076, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x80002b94, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x80636d24, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x807fffff, 0x9503366, 0x3c00080}, +{0x3c00000, 0x9503366, 0x80800000, 0x95033a6, 0x3c00000}, +{0x3c00000, 0x9503366, 0x80800002, 0x95033a6, 0x3c00010}, +{0x3c00000, 0x9503366, 0x81398437, 0x950341f, 0x3c00010}, +{0x3c00000, 0x9503366, 0x8ba98d27, 0xbb00ec2, 0x3c00010}, +{0x3c00000, 0x9503366, 0x8ba98d7a, 0xbb00f15, 0x3c00010}, +{0x3c00000, 0x9503366, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x9503366, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x9503366, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x9503366, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x9503366, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x9503366, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x9503366, 0x4f3495cb, 0xcf3495ca, 0x3c00010}, +{0x3c00000, 0x9503366, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0x9503366, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0x9503366, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0x9503366, 0x9503366, 0x0, 0x3c00000}, +{0x3c00000, 0x9503366, 0xbf5a97c9, 0x3f5a97c9, 0x3c00010}, +{0x3c00000, 0x9503366, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0x9503366, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0x9503366, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00010}, +{0x3c00000, 0x9503366, 0x966320b, 0x87aff528, 0x3c00000}, +{0x3c00000, 0x9503366, 0xb26bddee, 0x326bddee, 0x3c00010}, +{0x3c00000, 0x9503366, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00010}, +{0x3c00000, 0x9503366, 0x317285d3, 0xb17285d2, 0x3c00010}, +{0x3c00000, 0x9503366, 0x3c9623b1, 0xbc9623b0, 0x3c00010}, +{0x3c00000, 0x9503366, 0x51fd2c7c, 0xd1fd2c7b, 0x3c00010}, +{0x3c00000, 0x9503366, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x0, 0xbf5a97c9, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x1, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x76, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x2b94, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x636d24, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x7fffff, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x800000, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x800002, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x1398437, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xba98d27, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xba98d7a, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x80000000, 0xbf5a97c9, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x80000001, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x80000076, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x80002b94, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x80636d24, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x807fffff, 0xbf5a97c9, 0x3c00080}, +{0x3c00000, 0xbf5a97c9, 0x80800000, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x80800002, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x81398437, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x8ba98d27, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x8ba98d7a, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xbf5a97c9, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0x4f3495cb, 0xcf3495cb, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xe73a5134, 0x673a5133, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x6164bd6c, 0xe164bd6c, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x9503366, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xbf5a97c9, 0x0, 0x3c00000}, +{0x3c00000, 0xbf5a97c9, 0xe6ff1a14, 0x66ff1a13, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xaab4d7d8, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x966320b, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xb26bddee, 0xbf5a97c8, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0xb5c8e5d3, 0xbf5a97af, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x317285d3, 0xbf5a97c9, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x3c9623b1, 0xbf5f48e6, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00010}, +{0x3c00000, 0xbf5a97c9, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x0, 0xe6ff1a14, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x1, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x76, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x2b94, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x636d24, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x7fffff, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x800000, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x800002, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x1398437, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xba98d27, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xba98d7a, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x80000000, 0xe6ff1a14, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x80000001, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x80000076, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x80002b94, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x80636d24, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x807fffff, 0xe6ff1a14, 0x3c00080}, +{0x3c00000, 0xe6ff1a14, 0x80800000, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x80800002, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x81398437, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x8ba98d27, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x8ba98d7a, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xe6ff1a14, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x4f3495cb, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xe73a5134, 0x666b10a8, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x6164bd6c, 0xe6ff36ab, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x9503366, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xbf5a97c9, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xe6ff1a14, 0x0, 0x3c00000}, +{0x3c00000, 0xe6ff1a14, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xaab4d7d8, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x966320b, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xb26bddee, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0xb5c8e5d3, 0xe6ff1a13, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x317285d3, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x3c9623b1, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x51fd2c7c, 0xe6ff1a14, 0x3c00010}, +{0x3c00000, 0xe6ff1a14, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x0, 0x77f31e2f, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x1, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x76, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x2b94, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x636d24, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x7fffff, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x800000, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x800002, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x1398437, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xba98d27, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xba98d7a, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x751f853a, 0x77ee2205, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x7f7ffff0, 0xff7ffe09, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x7f7fffff, 0xff7ffe18, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x80000000, 0x77f31e2f, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x80000001, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x80000076, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x80002b94, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x80636d24, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x807fffff, 0x77f31e2f, 0x3c00080}, +{0x3c00000, 0x77f31e2f, 0x80800000, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x80800002, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x81398437, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x8ba98d27, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x8ba98d7a, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xf51f853a, 0x77f81a58, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xff7ffff0, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x77f31e2f, 0xff7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x77f31e2f, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x77f31e2f, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0x4f3495cb, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xe73a5134, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x7c994e9e, 0xfc9911d6, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x6164bd6c, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x9503366, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xbf5a97c9, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xe6ff1a14, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x77f31e2f, 0x0, 0x3c00000}, +{0x3c00000, 0x77f31e2f, 0xaab4d7d8, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x966320b, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xb26bddee, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0xb5c8e5d3, 0x77f31e2f, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x317285d3, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x3c9623b1, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x51fd2c7c, 0x77f31e2e, 0x3c00010}, +{0x3c00000, 0x77f31e2f, 0x7b906a6c, 0xfb8f774d, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x0, 0xaab4d7d8, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x1, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x76, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x2b94, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x636d24, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x7fffff, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x800000, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x800002, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x1398437, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xba98d27, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xba98d7a, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x80000000, 0xaab4d7d8, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x80000001, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x80000076, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x80002b94, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x80636d24, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x807fffff, 0xaab4d7d8, 0x3c00080}, +{0x3c00000, 0xaab4d7d8, 0x80800000, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x80800002, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x81398437, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x8ba98d27, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x8ba98d7a, 0xaab4d7d7, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xaab4d7d8, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x4f3495cb, 0xcf3495cb, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xe73a5134, 0x673a5133, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x6164bd6c, 0xe164bd6c, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x9503366, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xbf5a97c9, 0x3f5a97c8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xe6ff1a14, 0x66ff1a13, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xaab4d7d8, 0x0, 0x3c00000}, +{0x3c00000, 0xaab4d7d8, 0x966320b, 0xaab4d7d8, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xb26bddee, 0x326bdc84, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0xb5c8e5d3, 0x35c8e5d0, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x317285d3, 0xb1728b79, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x3c9623b1, 0xbc9623b1, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00010}, +{0x3c00000, 0xaab4d7d8, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0x966320b, 0x0, 0x966320b, 0x3c00000}, +{0x3c00000, 0x966320b, 0x1, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x76, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x2b94, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x636d24, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x7fffff, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x800000, 0x96631cb, 0x3c00000}, +{0x3c00000, 0x966320b, 0x800002, 0x96631ca, 0x3c00010}, +{0x3c00000, 0x966320b, 0x1398437, 0x9663151, 0x3c00010}, +{0x3c00000, 0x966320b, 0xba98d27, 0x8ba25b96, 0x3c00010}, +{0x3c00000, 0x966320b, 0xba98d7a, 0x8ba25be9, 0x3c00010}, +{0x3c00000, 0x966320b, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x966320b, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x966320b, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x966320b, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x966320b, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0x80000000, 0x966320b, 0x3c00000}, +{0x3c00000, 0x966320b, 0x80000001, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x80000076, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x80002b94, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x80636d24, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x807fffff, 0x966320b, 0x3c00080}, +{0x3c00000, 0x966320b, 0x80800000, 0x966324b, 0x3c00000}, +{0x3c00000, 0x966320b, 0x80800002, 0x966324b, 0x3c00010}, +{0x3c00000, 0x966320b, 0x81398437, 0x96632c4, 0x3c00010}, +{0x3c00000, 0x966320b, 0x8ba98d27, 0xbb0beb7, 0x3c00010}, +{0x3c00000, 0x966320b, 0x8ba98d7a, 0xbb0bf0a, 0x3c00010}, +{0x3c00000, 0x966320b, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x966320b, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x966320b, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x966320b, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x966320b, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x966320b, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x966320b, 0x4f3495cb, 0xcf3495ca, 0x3c00010}, +{0x3c00000, 0x966320b, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0x966320b, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0x966320b, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0x966320b, 0x9503366, 0x7aff528, 0x3c00000}, +{0x3c00000, 0x966320b, 0xbf5a97c9, 0x3f5a97c9, 0x3c00010}, +{0x3c00000, 0x966320b, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0x966320b, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0x966320b, 0xaab4d7d8, 0x2ab4d7d8, 0x3c00010}, +{0x3c00000, 0x966320b, 0x966320b, 0x0, 0x3c00000}, +{0x3c00000, 0x966320b, 0xb26bddee, 0x326bddee, 0x3c00010}, +{0x3c00000, 0x966320b, 0xb5c8e5d3, 0x35c8e5d3, 0x3c00010}, +{0x3c00000, 0x966320b, 0x317285d3, 0xb17285d2, 0x3c00010}, +{0x3c00000, 0x966320b, 0x3c9623b1, 0xbc9623b0, 0x3c00010}, +{0x3c00000, 0x966320b, 0x51fd2c7c, 0xd1fd2c7b, 0x3c00010}, +{0x3c00000, 0x966320b, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x0, 0xb26bddee, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x1, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x76, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x2b94, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x636d24, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x7fffff, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x800000, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x800002, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x1398437, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xba98d27, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xba98d7a, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x80000000, 0xb26bddee, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x80000001, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x80000076, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x80002b94, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x80636d24, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x807fffff, 0xb26bddee, 0x3c00080}, +{0x3c00000, 0xb26bddee, 0x80800000, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x80800002, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x81398437, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x8ba98d27, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x8ba98d7a, 0xb26bdded, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb26bddee, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0x4f3495cb, 0xcf3495cb, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xe73a5134, 0x673a5133, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x6164bd6c, 0xe164bd6c, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x9503366, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xbf5a97c9, 0x3f5a97c8, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xe6ff1a14, 0x66ff1a13, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xaab4d7d8, 0xb26bdc84, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x966320b, 0xb26bddee, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0xb26bddee, 0x0, 0x3c00000}, +{0x3c00000, 0xb26bddee, 0xb5c8e5d3, 0x35c70e17, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x317285d3, 0xb2943fb1, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x3c9623b1, 0xbc9623b8, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00010}, +{0x3c00000, 0xb26bddee, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x0, 0xb5c8e5d3, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x1, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x76, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x2b94, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x636d24, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x7fffff, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x800000, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x800002, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x1398437, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xba98d27, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xba98d7a, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x751f853a, 0xf51f853a, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x7f7ffff0, 0xff7ffff0, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x7f7fffff, 0xff7fffff, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x80000000, 0xb5c8e5d3, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x80000001, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x80000076, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x80002b94, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x80636d24, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x807fffff, 0xb5c8e5d3, 0x3c00080}, +{0x3c00000, 0xb5c8e5d3, 0x80800000, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x80800002, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x81398437, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x8ba98d27, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x8ba98d7a, 0xb5c8e5d2, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xf51f853a, 0x751f8539, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xff7ffff0, 0x7f7fffef, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xff7fffff, 0x7f7ffffe, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0xb5c8e5d3, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x4f3495cb, 0xcf3495cb, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xe73a5134, 0x673a5133, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x7c994e9e, 0xfc994e9e, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x6164bd6c, 0xe164bd6c, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x9503366, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xbf5a97c9, 0x3f5a97af, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xe6ff1a14, 0x66ff1a13, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x77f31e2f, 0xf7f31e2f, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xaab4d7d8, 0xb5c8e5d0, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x966320b, 0xb5c8e5d3, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xb26bddee, 0xb5c70e17, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0xb5c8e5d3, 0x0, 0x3c00000}, +{0x3c00000, 0xb5c8e5d3, 0x317285d3, 0xb5c95f15, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x3c9623b1, 0xbc9626d4, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x51fd2c7c, 0xd1fd2c7c, 0x3c00010}, +{0x3c00000, 0xb5c8e5d3, 0x7b906a6c, 0xfb906a6c, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x0, 0x317285d3, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x1, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x76, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x2b94, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x636d24, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x7fffff, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x800000, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x800002, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x1398437, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xba98d27, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xba98d7a, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x80000000, 0x317285d3, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x80000001, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x80000076, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x80002b94, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x80636d24, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x807fffff, 0x317285d3, 0x3c00080}, +{0x3c00000, 0x317285d3, 0x80800000, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x80800002, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x81398437, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x8ba98d27, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x8ba98d7a, 0x317285d3, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x317285d3, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x4f3495cb, 0xcf3495ca, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x9503366, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xbf5a97c9, 0x3f5a97c9, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xaab4d7d8, 0x31728b79, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x966320b, 0x317285d2, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xb26bddee, 0x32943fb1, 0x3c00010}, +{0x3c00000, 0x317285d3, 0xb5c8e5d3, 0x35c95f15, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x317285d3, 0x0, 0x3c00000}, +{0x3c00000, 0x317285d3, 0x3c9623b1, 0xbc9623af, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x51fd2c7c, 0xd1fd2c7b, 0x3c00010}, +{0x3c00000, 0x317285d3, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x0, 0x3c9623b1, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x1, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x76, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x2b94, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x636d24, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x7fffff, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x800000, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x800002, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x1398437, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xba98d27, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xba98d7a, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x80000000, 0x3c9623b1, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x80000001, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x80000076, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x80002b94, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x80636d24, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x807fffff, 0x3c9623b1, 0x3c00080}, +{0x3c00000, 0x3c9623b1, 0x80800000, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x80800002, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x81398437, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x8ba98d27, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x8ba98d7a, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x3c9623b1, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x4f3495cb, 0xcf3495ca, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x9503366, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xbf5a97c9, 0x3f5f48e6, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xaab4d7d8, 0x3c9623b1, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x966320b, 0x3c9623b0, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xb26bddee, 0x3c9623b8, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0xb5c8e5d3, 0x3c9626d4, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x317285d3, 0x3c9623af, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x3c9623b1, 0x0, 0x3c00000}, +{0x3c00000, 0x3c9623b1, 0x51fd2c7c, 0xd1fd2c7b, 0x3c00010}, +{0x3c00000, 0x3c9623b1, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x0, 0x51fd2c7c, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x1, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x76, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x2b94, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x636d24, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x7fffff, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x800000, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x800002, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x1398437, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xba98d27, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xba98d7a, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x751f853a, 0xf51f8539, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x7f7ffff0, 0xff7fffef, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x7f7fffff, 0xff7ffffe, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x80000000, 0x51fd2c7c, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x80000001, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x80000076, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x80002b94, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x80636d24, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x807fffff, 0x51fd2c7c, 0x3c00080}, +{0x3c00000, 0x51fd2c7c, 0x80800000, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x80800002, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x81398437, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x8ba98d27, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x8ba98d7a, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xf51f853a, 0x751f853a, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xff7ffff0, 0x7f7ffff0, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xff7fffff, 0x7f7fffff, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x51fd2c7c, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x4f3495cb, 0x51f787cd, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xe73a5134, 0x673a5134, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x7c994e9e, 0xfc994e9d, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x6164bd6c, 0xe164bd6b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x9503366, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xbf5a97c9, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xe6ff1a14, 0x66ff1a14, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x77f31e2f, 0xf7f31e2e, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xaab4d7d8, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x966320b, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xb26bddee, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0xb5c8e5d3, 0x51fd2c7c, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x317285d3, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x3c9623b1, 0x51fd2c7b, 0x3c00010}, +{0x3c00000, 0x51fd2c7c, 0x51fd2c7c, 0x0, 0x3c00000}, +{0x3c00000, 0x51fd2c7c, 0x7b906a6c, 0xfb906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x0, 0x7b906a6c, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x1, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x76, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x2b94, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x636d24, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x7fffff, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x800000, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x800002, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x1398437, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xba98d27, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xba98d7a, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x751f853a, 0x7b90656f, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x7f7ffff0, 0xff7edf1b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x7f7fffff, 0xff7edf2a, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x7f800000, 0xff800000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x7f800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0x7f984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0x7fbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0x7fc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x7fd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x7fffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x80000000, 0x7b906a6c, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x80000001, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x80000076, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x80002b94, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x80636d24, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x807fffff, 0x7b906a6c, 0x3c00080}, +{0x3c00000, 0x7b906a6c, 0x80800000, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x80800002, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x81398437, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x8ba98d27, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x8ba98d7a, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xf51f853a, 0x7b906f68, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xff7ffff0, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7b906a6c, 0xff7fffff, 0x7f7fffff, 0x3c00014}, +{0x3c00000, 0x7b906a6c, 0xff800000, 0x7f800000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0xff800001, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0xff984a37, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0xffbfffff, 0x7fc00000, 0x3c00001}, +{0x3c00000, 0x7b906a6c, 0xffc00000, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0xffd9ba98, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0xffffffff, 0x7fc00000, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x4f3495cb, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xe73a5134, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x7c994e9e, 0xfc6a6806, 0x3c00000}, +{0x3c00000, 0x7b906a6c, 0x6164bd6c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x9503366, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xbf5a97c9, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xe6ff1a14, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x77f31e2f, 0x7b8f774d, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xaab4d7d8, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x966320b, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xb26bddee, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0xb5c8e5d3, 0x7b906a6c, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x317285d3, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x3c9623b1, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x51fd2c7c, 0x7b906a6b, 0x3c00010}, +{0x3c00000, 0x7b906a6c, 0x7b906a6c, 0x0, 0x3c00000}, +{0x3800000, 0x0, 0x0, 0x80000000, 0x3800000}, +{0x3800000, 0x0, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x0, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x0, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x0, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x0, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x0, 0x800000, 0x80800000, 0x3800000}, +{0x3800000, 0x0, 0x800002, 0x80800002, 0x3800000}, +{0x3800000, 0x0, 0x1398437, 0x81398437, 0x3800000}, +{0x3800000, 0x0, 0xba98d27, 0x8ba98d27, 0x3800000}, +{0x3800000, 0x0, 0xba98d7a, 0x8ba98d7a, 0x3800000}, +{0x3800000, 0x0, 0x751f853a, 0xf51f853a, 0x3800000}, +{0x3800000, 0x0, 0x7f7ffff0, 0xff7ffff0, 0x3800000}, +{0x3800000, 0x0, 0x7f7fffff, 0xff7fffff, 0x3800000}, +{0x3800000, 0x0, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x0, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0x80000000, 0x0, 0x3800000}, +{0x3800000, 0x0, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x0, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x0, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x0, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x0, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x0, 0x80800000, 0x800000, 0x3800000}, +{0x3800000, 0x0, 0x80800002, 0x800002, 0x3800000}, +{0x3800000, 0x0, 0x81398437, 0x1398437, 0x3800000}, +{0x3800000, 0x0, 0x8ba98d27, 0xba98d27, 0x3800000}, +{0x3800000, 0x0, 0x8ba98d7a, 0xba98d7a, 0x3800000}, +{0x3800000, 0x0, 0xf51f853a, 0x751f853a, 0x3800000}, +{0x3800000, 0x0, 0xff7ffff0, 0x7f7ffff0, 0x3800000}, +{0x3800000, 0x0, 0xff7fffff, 0x7f7fffff, 0x3800000}, +{0x3800000, 0x0, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x0, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x0, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x0, 0x4f3495cb, 0xcf3495cb, 0x3800000}, +{0x3800000, 0x0, 0xe73a5134, 0x673a5134, 0x3800000}, +{0x3800000, 0x0, 0x7c994e9e, 0xfc994e9e, 0x3800000}, +{0x3800000, 0x0, 0x6164bd6c, 0xe164bd6c, 0x3800000}, +{0x3800000, 0x0, 0x9503366, 0x89503366, 0x3800000}, +{0x3800000, 0x0, 0xbf5a97c9, 0x3f5a97c9, 0x3800000}, +{0x3800000, 0x0, 0xe6ff1a14, 0x66ff1a14, 0x3800000}, +{0x3800000, 0x0, 0x77f31e2f, 0xf7f31e2f, 0x3800000}, +{0x3800000, 0x0, 0xaab4d7d8, 0x2ab4d7d8, 0x3800000}, +{0x3800000, 0x0, 0x966320b, 0x8966320b, 0x3800000}, +{0x3800000, 0x0, 0xb26bddee, 0x326bddee, 0x3800000}, +{0x3800000, 0x0, 0xb5c8e5d3, 0x35c8e5d3, 0x3800000}, +{0x3800000, 0x0, 0x317285d3, 0xb17285d3, 0x3800000}, +{0x3800000, 0x0, 0x3c9623b1, 0xbc9623b1, 0x3800000}, +{0x3800000, 0x0, 0x51fd2c7c, 0xd1fd2c7c, 0x3800000}, +{0x3800000, 0x0, 0x7b906a6c, 0xfb906a6c, 0x3800000}, +{0x3800000, 0x1, 0x0, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x800000, 0x80800000, 0x3800080}, +{0x3800000, 0x1, 0x800002, 0x80800002, 0x3800080}, +{0x3800000, 0x1, 0x1398437, 0x81398437, 0x3800080}, +{0x3800000, 0x1, 0xba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x1, 0xba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x1, 0x751f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x1, 0x7f7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x1, 0x7f7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x1, 0x7f800000, 0xff800000, 0x3800080}, +{0x3800000, 0x1, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0x80000000, 0x0, 0x3800080}, +{0x3800000, 0x1, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x1, 0x80800000, 0x800000, 0x3800080}, +{0x3800000, 0x1, 0x80800002, 0x800002, 0x3800080}, +{0x3800000, 0x1, 0x81398437, 0x1398437, 0x3800080}, +{0x3800000, 0x1, 0x8ba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x1, 0x8ba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x1, 0xf51f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x1, 0xff7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x1, 0xff7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x1, 0xff800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x1, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x1, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x1, 0x4f3495cb, 0xcf3495cb, 0x3800080}, +{0x3800000, 0x1, 0xe73a5134, 0x673a5134, 0x3800080}, +{0x3800000, 0x1, 0x7c994e9e, 0xfc994e9e, 0x3800080}, +{0x3800000, 0x1, 0x6164bd6c, 0xe164bd6c, 0x3800080}, +{0x3800000, 0x1, 0x9503366, 0x89503366, 0x3800080}, +{0x3800000, 0x1, 0xbf5a97c9, 0x3f5a97c9, 0x3800080}, +{0x3800000, 0x1, 0xe6ff1a14, 0x66ff1a14, 0x3800080}, +{0x3800000, 0x1, 0x77f31e2f, 0xf7f31e2f, 0x3800080}, +{0x3800000, 0x1, 0xaab4d7d8, 0x2ab4d7d8, 0x3800080}, +{0x3800000, 0x1, 0x966320b, 0x8966320b, 0x3800080}, +{0x3800000, 0x1, 0xb26bddee, 0x326bddee, 0x3800080}, +{0x3800000, 0x1, 0xb5c8e5d3, 0x35c8e5d3, 0x3800080}, +{0x3800000, 0x1, 0x317285d3, 0xb17285d3, 0x3800080}, +{0x3800000, 0x1, 0x3c9623b1, 0xbc9623b1, 0x3800080}, +{0x3800000, 0x1, 0x51fd2c7c, 0xd1fd2c7c, 0x3800080}, +{0x3800000, 0x1, 0x7b906a6c, 0xfb906a6c, 0x3800080}, +{0x3800000, 0x76, 0x0, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x800000, 0x80800000, 0x3800080}, +{0x3800000, 0x76, 0x800002, 0x80800002, 0x3800080}, +{0x3800000, 0x76, 0x1398437, 0x81398437, 0x3800080}, +{0x3800000, 0x76, 0xba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x76, 0xba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x76, 0x751f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x76, 0x7f7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x76, 0x7f7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x76, 0x7f800000, 0xff800000, 0x3800080}, +{0x3800000, 0x76, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0x80000000, 0x0, 0x3800080}, +{0x3800000, 0x76, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x76, 0x80800000, 0x800000, 0x3800080}, +{0x3800000, 0x76, 0x80800002, 0x800002, 0x3800080}, +{0x3800000, 0x76, 0x81398437, 0x1398437, 0x3800080}, +{0x3800000, 0x76, 0x8ba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x76, 0x8ba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x76, 0xf51f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x76, 0xff7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x76, 0xff7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x76, 0xff800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x76, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x76, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x76, 0x4f3495cb, 0xcf3495cb, 0x3800080}, +{0x3800000, 0x76, 0xe73a5134, 0x673a5134, 0x3800080}, +{0x3800000, 0x76, 0x7c994e9e, 0xfc994e9e, 0x3800080}, +{0x3800000, 0x76, 0x6164bd6c, 0xe164bd6c, 0x3800080}, +{0x3800000, 0x76, 0x9503366, 0x89503366, 0x3800080}, +{0x3800000, 0x76, 0xbf5a97c9, 0x3f5a97c9, 0x3800080}, +{0x3800000, 0x76, 0xe6ff1a14, 0x66ff1a14, 0x3800080}, +{0x3800000, 0x76, 0x77f31e2f, 0xf7f31e2f, 0x3800080}, +{0x3800000, 0x76, 0xaab4d7d8, 0x2ab4d7d8, 0x3800080}, +{0x3800000, 0x76, 0x966320b, 0x8966320b, 0x3800080}, +{0x3800000, 0x76, 0xb26bddee, 0x326bddee, 0x3800080}, +{0x3800000, 0x76, 0xb5c8e5d3, 0x35c8e5d3, 0x3800080}, +{0x3800000, 0x76, 0x317285d3, 0xb17285d3, 0x3800080}, +{0x3800000, 0x76, 0x3c9623b1, 0xbc9623b1, 0x3800080}, +{0x3800000, 0x76, 0x51fd2c7c, 0xd1fd2c7c, 0x3800080}, +{0x3800000, 0x76, 0x7b906a6c, 0xfb906a6c, 0x3800080}, +{0x3800000, 0x2b94, 0x0, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x800000, 0x80800000, 0x3800080}, +{0x3800000, 0x2b94, 0x800002, 0x80800002, 0x3800080}, +{0x3800000, 0x2b94, 0x1398437, 0x81398437, 0x3800080}, +{0x3800000, 0x2b94, 0xba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x2b94, 0xba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x2b94, 0x751f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x2b94, 0x7f7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x2b94, 0x7f7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x2b94, 0x7f800000, 0xff800000, 0x3800080}, +{0x3800000, 0x2b94, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0x80000000, 0x0, 0x3800080}, +{0x3800000, 0x2b94, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x2b94, 0x80800000, 0x800000, 0x3800080}, +{0x3800000, 0x2b94, 0x80800002, 0x800002, 0x3800080}, +{0x3800000, 0x2b94, 0x81398437, 0x1398437, 0x3800080}, +{0x3800000, 0x2b94, 0x8ba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x2b94, 0x8ba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x2b94, 0xf51f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x2b94, 0xff7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x2b94, 0xff7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x2b94, 0xff800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x2b94, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x2b94, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x2b94, 0x4f3495cb, 0xcf3495cb, 0x3800080}, +{0x3800000, 0x2b94, 0xe73a5134, 0x673a5134, 0x3800080}, +{0x3800000, 0x2b94, 0x7c994e9e, 0xfc994e9e, 0x3800080}, +{0x3800000, 0x2b94, 0x6164bd6c, 0xe164bd6c, 0x3800080}, +{0x3800000, 0x2b94, 0x9503366, 0x89503366, 0x3800080}, +{0x3800000, 0x2b94, 0xbf5a97c9, 0x3f5a97c9, 0x3800080}, +{0x3800000, 0x2b94, 0xe6ff1a14, 0x66ff1a14, 0x3800080}, +{0x3800000, 0x2b94, 0x77f31e2f, 0xf7f31e2f, 0x3800080}, +{0x3800000, 0x2b94, 0xaab4d7d8, 0x2ab4d7d8, 0x3800080}, +{0x3800000, 0x2b94, 0x966320b, 0x8966320b, 0x3800080}, +{0x3800000, 0x2b94, 0xb26bddee, 0x326bddee, 0x3800080}, +{0x3800000, 0x2b94, 0xb5c8e5d3, 0x35c8e5d3, 0x3800080}, +{0x3800000, 0x2b94, 0x317285d3, 0xb17285d3, 0x3800080}, +{0x3800000, 0x2b94, 0x3c9623b1, 0xbc9623b1, 0x3800080}, +{0x3800000, 0x2b94, 0x51fd2c7c, 0xd1fd2c7c, 0x3800080}, +{0x3800000, 0x2b94, 0x7b906a6c, 0xfb906a6c, 0x3800080}, +{0x3800000, 0x636d24, 0x0, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x800000, 0x80800000, 0x3800080}, +{0x3800000, 0x636d24, 0x800002, 0x80800002, 0x3800080}, +{0x3800000, 0x636d24, 0x1398437, 0x81398437, 0x3800080}, +{0x3800000, 0x636d24, 0xba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x636d24, 0xba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x636d24, 0x751f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x636d24, 0x7f7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x636d24, 0x7f7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x636d24, 0x7f800000, 0xff800000, 0x3800080}, +{0x3800000, 0x636d24, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0x80000000, 0x0, 0x3800080}, +{0x3800000, 0x636d24, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x636d24, 0x80800000, 0x800000, 0x3800080}, +{0x3800000, 0x636d24, 0x80800002, 0x800002, 0x3800080}, +{0x3800000, 0x636d24, 0x81398437, 0x1398437, 0x3800080}, +{0x3800000, 0x636d24, 0x8ba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x636d24, 0x8ba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x636d24, 0xf51f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x636d24, 0xff7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x636d24, 0xff7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x636d24, 0xff800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x636d24, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x636d24, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x636d24, 0x4f3495cb, 0xcf3495cb, 0x3800080}, +{0x3800000, 0x636d24, 0xe73a5134, 0x673a5134, 0x3800080}, +{0x3800000, 0x636d24, 0x7c994e9e, 0xfc994e9e, 0x3800080}, +{0x3800000, 0x636d24, 0x6164bd6c, 0xe164bd6c, 0x3800080}, +{0x3800000, 0x636d24, 0x9503366, 0x89503366, 0x3800080}, +{0x3800000, 0x636d24, 0xbf5a97c9, 0x3f5a97c9, 0x3800080}, +{0x3800000, 0x636d24, 0xe6ff1a14, 0x66ff1a14, 0x3800080}, +{0x3800000, 0x636d24, 0x77f31e2f, 0xf7f31e2f, 0x3800080}, +{0x3800000, 0x636d24, 0xaab4d7d8, 0x2ab4d7d8, 0x3800080}, +{0x3800000, 0x636d24, 0x966320b, 0x8966320b, 0x3800080}, +{0x3800000, 0x636d24, 0xb26bddee, 0x326bddee, 0x3800080}, +{0x3800000, 0x636d24, 0xb5c8e5d3, 0x35c8e5d3, 0x3800080}, +{0x3800000, 0x636d24, 0x317285d3, 0xb17285d3, 0x3800080}, +{0x3800000, 0x636d24, 0x3c9623b1, 0xbc9623b1, 0x3800080}, +{0x3800000, 0x636d24, 0x51fd2c7c, 0xd1fd2c7c, 0x3800080}, +{0x3800000, 0x636d24, 0x7b906a6c, 0xfb906a6c, 0x3800080}, +{0x3800000, 0x7fffff, 0x0, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x800000, 0x80800000, 0x3800080}, +{0x3800000, 0x7fffff, 0x800002, 0x80800002, 0x3800080}, +{0x3800000, 0x7fffff, 0x1398437, 0x81398437, 0x3800080}, +{0x3800000, 0x7fffff, 0xba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x7fffff, 0xba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x7fffff, 0x751f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x7fffff, 0x7f7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x7fffff, 0x7f7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x7fffff, 0x7f800000, 0xff800000, 0x3800080}, +{0x3800000, 0x7fffff, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0x80000000, 0x0, 0x3800080}, +{0x3800000, 0x7fffff, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x7fffff, 0x80800000, 0x800000, 0x3800080}, +{0x3800000, 0x7fffff, 0x80800002, 0x800002, 0x3800080}, +{0x3800000, 0x7fffff, 0x81398437, 0x1398437, 0x3800080}, +{0x3800000, 0x7fffff, 0x8ba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x7fffff, 0x8ba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x7fffff, 0xf51f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x7fffff, 0xff7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7fffff, 0xff7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7fffff, 0xff800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x7fffff, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fffff, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffff, 0x4f3495cb, 0xcf3495cb, 0x3800080}, +{0x3800000, 0x7fffff, 0xe73a5134, 0x673a5134, 0x3800080}, +{0x3800000, 0x7fffff, 0x7c994e9e, 0xfc994e9e, 0x3800080}, +{0x3800000, 0x7fffff, 0x6164bd6c, 0xe164bd6c, 0x3800080}, +{0x3800000, 0x7fffff, 0x9503366, 0x89503366, 0x3800080}, +{0x3800000, 0x7fffff, 0xbf5a97c9, 0x3f5a97c9, 0x3800080}, +{0x3800000, 0x7fffff, 0xe6ff1a14, 0x66ff1a14, 0x3800080}, +{0x3800000, 0x7fffff, 0x77f31e2f, 0xf7f31e2f, 0x3800080}, +{0x3800000, 0x7fffff, 0xaab4d7d8, 0x2ab4d7d8, 0x3800080}, +{0x3800000, 0x7fffff, 0x966320b, 0x8966320b, 0x3800080}, +{0x3800000, 0x7fffff, 0xb26bddee, 0x326bddee, 0x3800080}, +{0x3800000, 0x7fffff, 0xb5c8e5d3, 0x35c8e5d3, 0x3800080}, +{0x3800000, 0x7fffff, 0x317285d3, 0xb17285d3, 0x3800080}, +{0x3800000, 0x7fffff, 0x3c9623b1, 0xbc9623b1, 0x3800080}, +{0x3800000, 0x7fffff, 0x51fd2c7c, 0xd1fd2c7c, 0x3800080}, +{0x3800000, 0x7fffff, 0x7b906a6c, 0xfb906a6c, 0x3800080}, +{0x3800000, 0x800000, 0x0, 0x800000, 0x3800000}, +{0x3800000, 0x800000, 0x1, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x76, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x2b94, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x636d24, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x7fffff, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x800000, 0x80000000, 0x3800000}, +{0x3800000, 0x800000, 0x800002, 0x0, 0x3800008}, +{0x3800000, 0x800000, 0x1398437, 0x80f3086e, 0x3800000}, +{0x3800000, 0x800000, 0xba98d27, 0x8ba98d25, 0x3800000}, +{0x3800000, 0x800000, 0xba98d7a, 0x8ba98d78, 0x3800000}, +{0x3800000, 0x800000, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x800000, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x800000, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x800000, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x800000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0x80000000, 0x800000, 0x3800000}, +{0x3800000, 0x800000, 0x80000001, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x80000076, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x80002b94, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x80636d24, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x807fffff, 0x800000, 0x3800080}, +{0x3800000, 0x800000, 0x80800000, 0x1000000, 0x3800000}, +{0x3800000, 0x800000, 0x80800002, 0x1000001, 0x3800000}, +{0x3800000, 0x800000, 0x81398437, 0x1798437, 0x3800000}, +{0x3800000, 0x800000, 0x8ba98d27, 0xba98d29, 0x3800000}, +{0x3800000, 0x800000, 0x8ba98d7a, 0xba98d7c, 0x3800000}, +{0x3800000, 0x800000, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x800000, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x800000, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x800000, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x800000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800000, 0x4f3495cb, 0xcf3495cb, 0x3800010}, +{0x3800000, 0x800000, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0x800000, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0x800000, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0x800000, 0x9503366, 0x89503326, 0x3800000}, +{0x3800000, 0x800000, 0xbf5a97c9, 0x3f5a97c9, 0x3800010}, +{0x3800000, 0x800000, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0x800000, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0x800000, 0xaab4d7d8, 0x2ab4d7d8, 0x3800010}, +{0x3800000, 0x800000, 0x966320b, 0x896631cb, 0x3800000}, +{0x3800000, 0x800000, 0xb26bddee, 0x326bddee, 0x3800010}, +{0x3800000, 0x800000, 0xb5c8e5d3, 0x35c8e5d3, 0x3800010}, +{0x3800000, 0x800000, 0x317285d3, 0xb17285d3, 0x3800010}, +{0x3800000, 0x800000, 0x3c9623b1, 0xbc9623b1, 0x3800010}, +{0x3800000, 0x800000, 0x51fd2c7c, 0xd1fd2c7c, 0x3800010}, +{0x3800000, 0x800000, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0x800002, 0x0, 0x800002, 0x3800000}, +{0x3800000, 0x800002, 0x1, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x76, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x2b94, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x636d24, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x7fffff, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x800000, 0x0, 0x3800008}, +{0x3800000, 0x800002, 0x800002, 0x80000000, 0x3800000}, +{0x3800000, 0x800002, 0x1398437, 0x80f3086c, 0x3800000}, +{0x3800000, 0x800002, 0xba98d27, 0x8ba98d25, 0x3800010}, +{0x3800000, 0x800002, 0xba98d7a, 0x8ba98d78, 0x3800010}, +{0x3800000, 0x800002, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x800002, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x800002, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x800002, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x800002, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0x80000000, 0x800002, 0x3800000}, +{0x3800000, 0x800002, 0x80000001, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x80000076, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x80002b94, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x80636d24, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x807fffff, 0x800002, 0x3800080}, +{0x3800000, 0x800002, 0x80800000, 0x1000001, 0x3800000}, +{0x3800000, 0x800002, 0x80800002, 0x1000002, 0x3800000}, +{0x3800000, 0x800002, 0x81398437, 0x1798438, 0x3800000}, +{0x3800000, 0x800002, 0x8ba98d27, 0xba98d29, 0x3800010}, +{0x3800000, 0x800002, 0x8ba98d7a, 0xba98d7c, 0x3800010}, +{0x3800000, 0x800002, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x800002, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x800002, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x800002, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x800002, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x800002, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x800002, 0x4f3495cb, 0xcf3495cb, 0x3800010}, +{0x3800000, 0x800002, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0x800002, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0x800002, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0x800002, 0x9503366, 0x89503326, 0x3800010}, +{0x3800000, 0x800002, 0xbf5a97c9, 0x3f5a97c9, 0x3800010}, +{0x3800000, 0x800002, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0x800002, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0x800002, 0xaab4d7d8, 0x2ab4d7d8, 0x3800010}, +{0x3800000, 0x800002, 0x966320b, 0x896631cb, 0x3800010}, +{0x3800000, 0x800002, 0xb26bddee, 0x326bddee, 0x3800010}, +{0x3800000, 0x800002, 0xb5c8e5d3, 0x35c8e5d3, 0x3800010}, +{0x3800000, 0x800002, 0x317285d3, 0xb17285d3, 0x3800010}, +{0x3800000, 0x800002, 0x3c9623b1, 0xbc9623b1, 0x3800010}, +{0x3800000, 0x800002, 0x51fd2c7c, 0xd1fd2c7c, 0x3800010}, +{0x3800000, 0x800002, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0x1398437, 0x0, 0x1398437, 0x3800000}, +{0x3800000, 0x1398437, 0x1, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x76, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x2b94, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x636d24, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x7fffff, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x800000, 0xf3086e, 0x3800000}, +{0x3800000, 0x1398437, 0x800002, 0xf3086c, 0x3800000}, +{0x3800000, 0x1398437, 0x1398437, 0x80000000, 0x3800000}, +{0x3800000, 0x1398437, 0xba98d27, 0x8ba98d22, 0x3800010}, +{0x3800000, 0x1398437, 0xba98d7a, 0x8ba98d75, 0x3800010}, +{0x3800000, 0x1398437, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x1398437, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x1398437, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x1398437, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x1398437, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0x80000000, 0x1398437, 0x3800000}, +{0x3800000, 0x1398437, 0x80000001, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x80000076, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x80002b94, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x80636d24, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x807fffff, 0x1398437, 0x3800080}, +{0x3800000, 0x1398437, 0x80800000, 0x1798437, 0x3800000}, +{0x3800000, 0x1398437, 0x80800002, 0x1798438, 0x3800000}, +{0x3800000, 0x1398437, 0x81398437, 0x1b98437, 0x3800000}, +{0x3800000, 0x1398437, 0x8ba98d27, 0xba98d2c, 0x3800010}, +{0x3800000, 0x1398437, 0x8ba98d7a, 0xba98d7f, 0x3800010}, +{0x3800000, 0x1398437, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x1398437, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x1398437, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x1398437, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x1398437, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x1398437, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x1398437, 0x4f3495cb, 0xcf3495cb, 0x3800010}, +{0x3800000, 0x1398437, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0x1398437, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0x1398437, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0x1398437, 0x9503366, 0x895032ad, 0x3800010}, +{0x3800000, 0x1398437, 0xbf5a97c9, 0x3f5a97c9, 0x3800010}, +{0x3800000, 0x1398437, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0x1398437, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0x1398437, 0xaab4d7d8, 0x2ab4d7d8, 0x3800010}, +{0x3800000, 0x1398437, 0x966320b, 0x89663152, 0x3800010}, +{0x3800000, 0x1398437, 0xb26bddee, 0x326bddee, 0x3800010}, +{0x3800000, 0x1398437, 0xb5c8e5d3, 0x35c8e5d3, 0x3800010}, +{0x3800000, 0x1398437, 0x317285d3, 0xb17285d3, 0x3800010}, +{0x3800000, 0x1398437, 0x3c9623b1, 0xbc9623b1, 0x3800010}, +{0x3800000, 0x1398437, 0x51fd2c7c, 0xd1fd2c7c, 0x3800010}, +{0x3800000, 0x1398437, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0xba98d27, 0x0, 0xba98d27, 0x3800000}, +{0x3800000, 0xba98d27, 0x1, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x76, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x2b94, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x636d24, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x7fffff, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x800000, 0xba98d25, 0x3800000}, +{0x3800000, 0xba98d27, 0x800002, 0xba98d24, 0x3800010}, +{0x3800000, 0xba98d27, 0x1398437, 0xba98d21, 0x3800010}, +{0x3800000, 0xba98d27, 0xba98d27, 0x80000000, 0x3800000}, +{0x3800000, 0xba98d27, 0xba98d7a, 0x83260000, 0x3800000}, +{0x3800000, 0xba98d27, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0xba98d27, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xba98d27, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0xba98d27, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xba98d27, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0x80000000, 0xba98d27, 0x3800000}, +{0x3800000, 0xba98d27, 0x80000001, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x80000076, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x80002b94, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x80636d24, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x807fffff, 0xba98d27, 0x3800080}, +{0x3800000, 0xba98d27, 0x80800000, 0xba98d29, 0x3800000}, +{0x3800000, 0xba98d27, 0x80800002, 0xba98d29, 0x3800010}, +{0x3800000, 0xba98d27, 0x81398437, 0xba98d2c, 0x3800010}, +{0x3800000, 0xba98d27, 0x8ba98d27, 0xc298d27, 0x3800000}, +{0x3800000, 0xba98d27, 0x8ba98d7a, 0xc298d50, 0x3800010}, +{0x3800000, 0xba98d27, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0xba98d27, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0xba98d27, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0xba98d27, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xba98d27, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d27, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d27, 0x4f3495cb, 0xcf3495cb, 0x3800010}, +{0x3800000, 0xba98d27, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0xba98d27, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0xba98d27, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0xba98d27, 0x9503366, 0xba30b8b, 0x3800010}, +{0x3800000, 0xba98d27, 0xbf5a97c9, 0x3f5a97c9, 0x3800010}, +{0x3800000, 0xba98d27, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0xba98d27, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0xba98d27, 0xaab4d7d8, 0x2ab4d7d8, 0x3800010}, +{0x3800000, 0xba98d27, 0x966320b, 0xba25b96, 0x3800010}, +{0x3800000, 0xba98d27, 0xb26bddee, 0x326bddee, 0x3800010}, +{0x3800000, 0xba98d27, 0xb5c8e5d3, 0x35c8e5d3, 0x3800010}, +{0x3800000, 0xba98d27, 0x317285d3, 0xb17285d3, 0x3800010}, +{0x3800000, 0xba98d27, 0x3c9623b1, 0xbc9623b1, 0x3800010}, +{0x3800000, 0xba98d27, 0x51fd2c7c, 0xd1fd2c7c, 0x3800010}, +{0x3800000, 0xba98d27, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0xba98d7a, 0x0, 0xba98d7a, 0x3800000}, +{0x3800000, 0xba98d7a, 0x1, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x76, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x2b94, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x636d24, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x7fffff, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x800000, 0xba98d78, 0x3800000}, +{0x3800000, 0xba98d7a, 0x800002, 0xba98d77, 0x3800010}, +{0x3800000, 0xba98d7a, 0x1398437, 0xba98d74, 0x3800010}, +{0x3800000, 0xba98d7a, 0xba98d27, 0x3260000, 0x3800000}, +{0x3800000, 0xba98d7a, 0xba98d7a, 0x80000000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0xba98d7a, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xba98d7a, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0xba98d7a, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x80000000, 0xba98d7a, 0x3800000}, +{0x3800000, 0xba98d7a, 0x80000001, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x80000076, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x80002b94, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x80636d24, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x807fffff, 0xba98d7a, 0x3800080}, +{0x3800000, 0xba98d7a, 0x80800000, 0xba98d7c, 0x3800000}, +{0x3800000, 0xba98d7a, 0x80800002, 0xba98d7c, 0x3800010}, +{0x3800000, 0xba98d7a, 0x81398437, 0xba98d7f, 0x3800010}, +{0x3800000, 0xba98d7a, 0x8ba98d27, 0xc298d50, 0x3800010}, +{0x3800000, 0xba98d7a, 0x8ba98d7a, 0xc298d7a, 0x3800000}, +{0x3800000, 0xba98d7a, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0xba98d7a, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0xba98d7a, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0xba98d7a, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xba98d7a, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xba98d7a, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xba98d7a, 0x4f3495cb, 0xcf3495cb, 0x3800010}, +{0x3800000, 0xba98d7a, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0xba98d7a, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0xba98d7a, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0xba98d7a, 0x9503366, 0xba30bde, 0x3800010}, +{0x3800000, 0xba98d7a, 0xbf5a97c9, 0x3f5a97c9, 0x3800010}, +{0x3800000, 0xba98d7a, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0xba98d7a, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0xba98d7a, 0xaab4d7d8, 0x2ab4d7d8, 0x3800010}, +{0x3800000, 0xba98d7a, 0x966320b, 0xba25be9, 0x3800010}, +{0x3800000, 0xba98d7a, 0xb26bddee, 0x326bddee, 0x3800010}, +{0x3800000, 0xba98d7a, 0xb5c8e5d3, 0x35c8e5d3, 0x3800010}, +{0x3800000, 0xba98d7a, 0x317285d3, 0xb17285d3, 0x3800010}, +{0x3800000, 0xba98d7a, 0x3c9623b1, 0xbc9623b1, 0x3800010}, +{0x3800000, 0xba98d7a, 0x51fd2c7c, 0xd1fd2c7c, 0x3800010}, +{0x3800000, 0xba98d7a, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0x751f853a, 0x0, 0x751f853a, 0x3800000}, +{0x3800000, 0x751f853a, 0x1, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x76, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x2b94, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x636d24, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x7fffff, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x800000, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x800002, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x1398437, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0xba98d27, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0xba98d7a, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x751f853a, 0x80000000, 0x3800000}, +{0x3800000, 0x751f853a, 0x7f7ffff0, 0xff7fffe7, 0x3800010}, +{0x3800000, 0x751f853a, 0x7f7fffff, 0xff7ffff6, 0x3800010}, +{0x3800000, 0x751f853a, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x751f853a, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0x80000000, 0x751f853a, 0x3800000}, +{0x3800000, 0x751f853a, 0x80000001, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x80000076, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x80002b94, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x80636d24, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x807fffff, 0x751f853a, 0x3800080}, +{0x3800000, 0x751f853a, 0x80800000, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x80800002, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x81398437, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x8ba98d27, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x8ba98d7a, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0xf51f853a, 0x759f853a, 0x3800000}, +{0x3800000, 0x751f853a, 0xff7ffff0, 0x7f7ffff9, 0x3800010}, +{0x3800000, 0x751f853a, 0xff7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x751f853a, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x751f853a, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x751f853a, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x751f853a, 0x4f3495cb, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0xe73a5134, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x7c994e9e, 0xfc994d5f, 0x3800010}, +{0x3800000, 0x751f853a, 0x6164bd6c, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x9503366, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0xbf5a97c9, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0xe6ff1a14, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x77f31e2f, 0xf7ee2206, 0x3800010}, +{0x3800000, 0x751f853a, 0xaab4d7d8, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x966320b, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0xb26bddee, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0xb5c8e5d3, 0x751f853a, 0x3800010}, +{0x3800000, 0x751f853a, 0x317285d3, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x3c9623b1, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x51fd2c7c, 0x751f8539, 0x3800010}, +{0x3800000, 0x751f853a, 0x7b906a6c, 0xfb906570, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x0, 0x7f7ffff0, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x1, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x76, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x2b94, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x636d24, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x7fffff, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x800000, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x800002, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x1398437, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xba98d27, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xba98d7a, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x751f853a, 0x7f7fffe6, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x7f7ffff0, 0x80000000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x7f7fffff, 0xf5700000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x80000000, 0x7f7ffff0, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x80000001, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x80000076, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x80002b94, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x80636d24, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x807fffff, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x7f7ffff0, 0x80800000, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x80800002, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x81398437, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x8ba98d27, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x8ba98d7a, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xf51f853a, 0x7f7ffff9, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xff7ffff0, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7ffff0, 0xff7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7ffff0, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7ffff0, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7ffff0, 0x4f3495cb, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xe73a5134, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x7c994e9e, 0x7f7b357b, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x6164bd6c, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x9503366, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xbf5a97c9, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xe6ff1a14, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x77f31e2f, 0x7f7ffe09, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xaab4d7d8, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x966320b, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xb26bddee, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0xb5c8e5d3, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x317285d3, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x3c9623b1, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x51fd2c7c, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x7f7ffff0, 0x7b906a6c, 0x7f7edf1b, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x0, 0x7f7fffff, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x1, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x76, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x2b94, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x636d24, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x800000, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x800002, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x1398437, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xba98d27, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xba98d7a, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x751f853a, 0x7f7ffff5, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x7f7ffff0, 0x75700000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x7f7fffff, 0x80000000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x80000000, 0x7f7fffff, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x80000001, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x80000076, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x80002b94, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x80636d24, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x807fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x7f7fffff, 0x80800000, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x80800002, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x81398437, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x8ba98d27, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x8ba98d7a, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xf51f853a, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7fffff, 0xff7ffff0, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7fffff, 0xff7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7f7fffff, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f7fffff, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f7fffff, 0x4f3495cb, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xe73a5134, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x7c994e9e, 0x7f7b358a, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x6164bd6c, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x9503366, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xbf5a97c9, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xe6ff1a14, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x77f31e2f, 0x7f7ffe18, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xaab4d7d8, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x966320b, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xb26bddee, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0xb5c8e5d3, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x317285d3, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x3c9623b1, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x51fd2c7c, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x7f7fffff, 0x7b906a6c, 0x7f7edf2a, 0x3800010}, +{0x3800000, 0x7f800000, 0x0, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x1, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x76, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x2b94, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x636d24, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x7fffff, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x800002, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x1398437, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xba98d27, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xba98d7a, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x751f853a, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7f7ffff0, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7f7fffff, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0x80000000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x80000001, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x80000076, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x80002b94, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x80636d24, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x807fffff, 0x7f800000, 0x3800080}, +{0x3800000, 0x7f800000, 0x80800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x80800002, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x81398437, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x8ba98d27, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x8ba98d7a, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xf51f853a, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xff7ffff0, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xff7fffff, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7f800000, 0x4f3495cb, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xe73a5134, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7c994e9e, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x6164bd6c, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x9503366, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xbf5a97c9, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xe6ff1a14, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x77f31e2f, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xaab4d7d8, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x966320b, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xb26bddee, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0xb5c8e5d3, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x317285d3, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x3c9623b1, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x51fd2c7c, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800000, 0x7b906a6c, 0x7f800000, 0x3800000}, +{0x3800000, 0x7f800001, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f800001, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f800001, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7f984a37, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7f984a37, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x7fbfffff, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fbfffff, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fc00000, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fc00000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fc00000, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fd9ba98, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fd9ba98, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fd9ba98, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x7fffffff, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7fffffff, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7fffffff, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0x0, 0x80000000, 0x3800000}, +{0x3800000, 0x80000000, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x800000, 0x80800000, 0x3800000}, +{0x3800000, 0x80000000, 0x800002, 0x80800002, 0x3800000}, +{0x3800000, 0x80000000, 0x1398437, 0x81398437, 0x3800000}, +{0x3800000, 0x80000000, 0xba98d27, 0x8ba98d27, 0x3800000}, +{0x3800000, 0x80000000, 0xba98d7a, 0x8ba98d7a, 0x3800000}, +{0x3800000, 0x80000000, 0x751f853a, 0xf51f853a, 0x3800000}, +{0x3800000, 0x80000000, 0x7f7ffff0, 0xff7ffff0, 0x3800000}, +{0x3800000, 0x80000000, 0x7f7fffff, 0xff7fffff, 0x3800000}, +{0x3800000, 0x80000000, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x80000000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0x80000000, 0x80000000, 0x3800000}, +{0x3800000, 0x80000000, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80000000, 0x80800000, 0x800000, 0x3800000}, +{0x3800000, 0x80000000, 0x80800002, 0x800002, 0x3800000}, +{0x3800000, 0x80000000, 0x81398437, 0x1398437, 0x3800000}, +{0x3800000, 0x80000000, 0x8ba98d27, 0xba98d27, 0x3800000}, +{0x3800000, 0x80000000, 0x8ba98d7a, 0xba98d7a, 0x3800000}, +{0x3800000, 0x80000000, 0xf51f853a, 0x751f853a, 0x3800000}, +{0x3800000, 0x80000000, 0xff7ffff0, 0x7f7ffff0, 0x3800000}, +{0x3800000, 0x80000000, 0xff7fffff, 0x7f7fffff, 0x3800000}, +{0x3800000, 0x80000000, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x80000000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80000000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80000000, 0x4f3495cb, 0xcf3495cb, 0x3800000}, +{0x3800000, 0x80000000, 0xe73a5134, 0x673a5134, 0x3800000}, +{0x3800000, 0x80000000, 0x7c994e9e, 0xfc994e9e, 0x3800000}, +{0x3800000, 0x80000000, 0x6164bd6c, 0xe164bd6c, 0x3800000}, +{0x3800000, 0x80000000, 0x9503366, 0x89503366, 0x3800000}, +{0x3800000, 0x80000000, 0xbf5a97c9, 0x3f5a97c9, 0x3800000}, +{0x3800000, 0x80000000, 0xe6ff1a14, 0x66ff1a14, 0x3800000}, +{0x3800000, 0x80000000, 0x77f31e2f, 0xf7f31e2f, 0x3800000}, +{0x3800000, 0x80000000, 0xaab4d7d8, 0x2ab4d7d8, 0x3800000}, +{0x3800000, 0x80000000, 0x966320b, 0x8966320b, 0x3800000}, +{0x3800000, 0x80000000, 0xb26bddee, 0x326bddee, 0x3800000}, +{0x3800000, 0x80000000, 0xb5c8e5d3, 0x35c8e5d3, 0x3800000}, +{0x3800000, 0x80000000, 0x317285d3, 0xb17285d3, 0x3800000}, +{0x3800000, 0x80000000, 0x3c9623b1, 0xbc9623b1, 0x3800000}, +{0x3800000, 0x80000000, 0x51fd2c7c, 0xd1fd2c7c, 0x3800000}, +{0x3800000, 0x80000000, 0x7b906a6c, 0xfb906a6c, 0x3800000}, +{0x3800000, 0x80000001, 0x0, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x800000, 0x80800000, 0x3800080}, +{0x3800000, 0x80000001, 0x800002, 0x80800002, 0x3800080}, +{0x3800000, 0x80000001, 0x1398437, 0x81398437, 0x3800080}, +{0x3800000, 0x80000001, 0xba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x80000001, 0xba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x80000001, 0x751f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x80000001, 0x7f7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x80000001, 0x7f7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x80000001, 0x7f800000, 0xff800000, 0x3800080}, +{0x3800000, 0x80000001, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0x80000000, 0x0, 0x3800080}, +{0x3800000, 0x80000001, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80000001, 0x80800000, 0x800000, 0x3800080}, +{0x3800000, 0x80000001, 0x80800002, 0x800002, 0x3800080}, +{0x3800000, 0x80000001, 0x81398437, 0x1398437, 0x3800080}, +{0x3800000, 0x80000001, 0x8ba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x80000001, 0x8ba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x80000001, 0xf51f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x80000001, 0xff7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x80000001, 0xff7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x80000001, 0xff800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x80000001, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000001, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000001, 0x4f3495cb, 0xcf3495cb, 0x3800080}, +{0x3800000, 0x80000001, 0xe73a5134, 0x673a5134, 0x3800080}, +{0x3800000, 0x80000001, 0x7c994e9e, 0xfc994e9e, 0x3800080}, +{0x3800000, 0x80000001, 0x6164bd6c, 0xe164bd6c, 0x3800080}, +{0x3800000, 0x80000001, 0x9503366, 0x89503366, 0x3800080}, +{0x3800000, 0x80000001, 0xbf5a97c9, 0x3f5a97c9, 0x3800080}, +{0x3800000, 0x80000001, 0xe6ff1a14, 0x66ff1a14, 0x3800080}, +{0x3800000, 0x80000001, 0x77f31e2f, 0xf7f31e2f, 0x3800080}, +{0x3800000, 0x80000001, 0xaab4d7d8, 0x2ab4d7d8, 0x3800080}, +{0x3800000, 0x80000001, 0x966320b, 0x8966320b, 0x3800080}, +{0x3800000, 0x80000001, 0xb26bddee, 0x326bddee, 0x3800080}, +{0x3800000, 0x80000001, 0xb5c8e5d3, 0x35c8e5d3, 0x3800080}, +{0x3800000, 0x80000001, 0x317285d3, 0xb17285d3, 0x3800080}, +{0x3800000, 0x80000001, 0x3c9623b1, 0xbc9623b1, 0x3800080}, +{0x3800000, 0x80000001, 0x51fd2c7c, 0xd1fd2c7c, 0x3800080}, +{0x3800000, 0x80000001, 0x7b906a6c, 0xfb906a6c, 0x3800080}, +{0x3800000, 0x80000076, 0x0, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x800000, 0x80800000, 0x3800080}, +{0x3800000, 0x80000076, 0x800002, 0x80800002, 0x3800080}, +{0x3800000, 0x80000076, 0x1398437, 0x81398437, 0x3800080}, +{0x3800000, 0x80000076, 0xba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x80000076, 0xba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x80000076, 0x751f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x80000076, 0x7f7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x80000076, 0x7f7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x80000076, 0x7f800000, 0xff800000, 0x3800080}, +{0x3800000, 0x80000076, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0x80000000, 0x0, 0x3800080}, +{0x3800000, 0x80000076, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80000076, 0x80800000, 0x800000, 0x3800080}, +{0x3800000, 0x80000076, 0x80800002, 0x800002, 0x3800080}, +{0x3800000, 0x80000076, 0x81398437, 0x1398437, 0x3800080}, +{0x3800000, 0x80000076, 0x8ba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x80000076, 0x8ba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x80000076, 0xf51f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x80000076, 0xff7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x80000076, 0xff7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x80000076, 0xff800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x80000076, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80000076, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80000076, 0x4f3495cb, 0xcf3495cb, 0x3800080}, +{0x3800000, 0x80000076, 0xe73a5134, 0x673a5134, 0x3800080}, +{0x3800000, 0x80000076, 0x7c994e9e, 0xfc994e9e, 0x3800080}, +{0x3800000, 0x80000076, 0x6164bd6c, 0xe164bd6c, 0x3800080}, +{0x3800000, 0x80000076, 0x9503366, 0x89503366, 0x3800080}, +{0x3800000, 0x80000076, 0xbf5a97c9, 0x3f5a97c9, 0x3800080}, +{0x3800000, 0x80000076, 0xe6ff1a14, 0x66ff1a14, 0x3800080}, +{0x3800000, 0x80000076, 0x77f31e2f, 0xf7f31e2f, 0x3800080}, +{0x3800000, 0x80000076, 0xaab4d7d8, 0x2ab4d7d8, 0x3800080}, +{0x3800000, 0x80000076, 0x966320b, 0x8966320b, 0x3800080}, +{0x3800000, 0x80000076, 0xb26bddee, 0x326bddee, 0x3800080}, +{0x3800000, 0x80000076, 0xb5c8e5d3, 0x35c8e5d3, 0x3800080}, +{0x3800000, 0x80000076, 0x317285d3, 0xb17285d3, 0x3800080}, +{0x3800000, 0x80000076, 0x3c9623b1, 0xbc9623b1, 0x3800080}, +{0x3800000, 0x80000076, 0x51fd2c7c, 0xd1fd2c7c, 0x3800080}, +{0x3800000, 0x80000076, 0x7b906a6c, 0xfb906a6c, 0x3800080}, +{0x3800000, 0x80002b94, 0x0, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x800000, 0x80800000, 0x3800080}, +{0x3800000, 0x80002b94, 0x800002, 0x80800002, 0x3800080}, +{0x3800000, 0x80002b94, 0x1398437, 0x81398437, 0x3800080}, +{0x3800000, 0x80002b94, 0xba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x80002b94, 0xba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x80002b94, 0x751f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x80002b94, 0x7f7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x80002b94, 0x7f7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x80002b94, 0x7f800000, 0xff800000, 0x3800080}, +{0x3800000, 0x80002b94, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0x80000000, 0x0, 0x3800080}, +{0x3800000, 0x80002b94, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80002b94, 0x80800000, 0x800000, 0x3800080}, +{0x3800000, 0x80002b94, 0x80800002, 0x800002, 0x3800080}, +{0x3800000, 0x80002b94, 0x81398437, 0x1398437, 0x3800080}, +{0x3800000, 0x80002b94, 0x8ba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x80002b94, 0x8ba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x80002b94, 0xf51f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x80002b94, 0xff7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x80002b94, 0xff7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x80002b94, 0xff800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x80002b94, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80002b94, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80002b94, 0x4f3495cb, 0xcf3495cb, 0x3800080}, +{0x3800000, 0x80002b94, 0xe73a5134, 0x673a5134, 0x3800080}, +{0x3800000, 0x80002b94, 0x7c994e9e, 0xfc994e9e, 0x3800080}, +{0x3800000, 0x80002b94, 0x6164bd6c, 0xe164bd6c, 0x3800080}, +{0x3800000, 0x80002b94, 0x9503366, 0x89503366, 0x3800080}, +{0x3800000, 0x80002b94, 0xbf5a97c9, 0x3f5a97c9, 0x3800080}, +{0x3800000, 0x80002b94, 0xe6ff1a14, 0x66ff1a14, 0x3800080}, +{0x3800000, 0x80002b94, 0x77f31e2f, 0xf7f31e2f, 0x3800080}, +{0x3800000, 0x80002b94, 0xaab4d7d8, 0x2ab4d7d8, 0x3800080}, +{0x3800000, 0x80002b94, 0x966320b, 0x8966320b, 0x3800080}, +{0x3800000, 0x80002b94, 0xb26bddee, 0x326bddee, 0x3800080}, +{0x3800000, 0x80002b94, 0xb5c8e5d3, 0x35c8e5d3, 0x3800080}, +{0x3800000, 0x80002b94, 0x317285d3, 0xb17285d3, 0x3800080}, +{0x3800000, 0x80002b94, 0x3c9623b1, 0xbc9623b1, 0x3800080}, +{0x3800000, 0x80002b94, 0x51fd2c7c, 0xd1fd2c7c, 0x3800080}, +{0x3800000, 0x80002b94, 0x7b906a6c, 0xfb906a6c, 0x3800080}, +{0x3800000, 0x80636d24, 0x0, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x800000, 0x80800000, 0x3800080}, +{0x3800000, 0x80636d24, 0x800002, 0x80800002, 0x3800080}, +{0x3800000, 0x80636d24, 0x1398437, 0x81398437, 0x3800080}, +{0x3800000, 0x80636d24, 0xba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x80636d24, 0xba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x80636d24, 0x751f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x80636d24, 0x7f7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x80636d24, 0x7f7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x80636d24, 0x7f800000, 0xff800000, 0x3800080}, +{0x3800000, 0x80636d24, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0x80000000, 0x0, 0x3800080}, +{0x3800000, 0x80636d24, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x80636d24, 0x80800000, 0x800000, 0x3800080}, +{0x3800000, 0x80636d24, 0x80800002, 0x800002, 0x3800080}, +{0x3800000, 0x80636d24, 0x81398437, 0x1398437, 0x3800080}, +{0x3800000, 0x80636d24, 0x8ba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x80636d24, 0x8ba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x80636d24, 0xf51f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x80636d24, 0xff7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x80636d24, 0xff7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x80636d24, 0xff800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x80636d24, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x80636d24, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x80636d24, 0x4f3495cb, 0xcf3495cb, 0x3800080}, +{0x3800000, 0x80636d24, 0xe73a5134, 0x673a5134, 0x3800080}, +{0x3800000, 0x80636d24, 0x7c994e9e, 0xfc994e9e, 0x3800080}, +{0x3800000, 0x80636d24, 0x6164bd6c, 0xe164bd6c, 0x3800080}, +{0x3800000, 0x80636d24, 0x9503366, 0x89503366, 0x3800080}, +{0x3800000, 0x80636d24, 0xbf5a97c9, 0x3f5a97c9, 0x3800080}, +{0x3800000, 0x80636d24, 0xe6ff1a14, 0x66ff1a14, 0x3800080}, +{0x3800000, 0x80636d24, 0x77f31e2f, 0xf7f31e2f, 0x3800080}, +{0x3800000, 0x80636d24, 0xaab4d7d8, 0x2ab4d7d8, 0x3800080}, +{0x3800000, 0x80636d24, 0x966320b, 0x8966320b, 0x3800080}, +{0x3800000, 0x80636d24, 0xb26bddee, 0x326bddee, 0x3800080}, +{0x3800000, 0x80636d24, 0xb5c8e5d3, 0x35c8e5d3, 0x3800080}, +{0x3800000, 0x80636d24, 0x317285d3, 0xb17285d3, 0x3800080}, +{0x3800000, 0x80636d24, 0x3c9623b1, 0xbc9623b1, 0x3800080}, +{0x3800000, 0x80636d24, 0x51fd2c7c, 0xd1fd2c7c, 0x3800080}, +{0x3800000, 0x80636d24, 0x7b906a6c, 0xfb906a6c, 0x3800080}, +{0x3800000, 0x807fffff, 0x0, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x1, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x76, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x2b94, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x7fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x800000, 0x80800000, 0x3800080}, +{0x3800000, 0x807fffff, 0x800002, 0x80800002, 0x3800080}, +{0x3800000, 0x807fffff, 0x1398437, 0x81398437, 0x3800080}, +{0x3800000, 0x807fffff, 0xba98d27, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x807fffff, 0xba98d7a, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x807fffff, 0x751f853a, 0xf51f853a, 0x3800080}, +{0x3800000, 0x807fffff, 0x7f7ffff0, 0xff7ffff0, 0x3800080}, +{0x3800000, 0x807fffff, 0x7f7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0x807fffff, 0x7f800000, 0xff800000, 0x3800080}, +{0x3800000, 0x807fffff, 0x7f800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0x7f984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0x7fbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0x7fc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0x7fd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0x7fffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0x80000000, 0x0, 0x3800080}, +{0x3800000, 0x807fffff, 0x80000001, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x80000076, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x80002b94, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x80636d24, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x807fffff, 0x80000000, 0x3800080}, +{0x3800000, 0x807fffff, 0x80800000, 0x800000, 0x3800080}, +{0x3800000, 0x807fffff, 0x80800002, 0x800002, 0x3800080}, +{0x3800000, 0x807fffff, 0x81398437, 0x1398437, 0x3800080}, +{0x3800000, 0x807fffff, 0x8ba98d27, 0xba98d27, 0x3800080}, +{0x3800000, 0x807fffff, 0x8ba98d7a, 0xba98d7a, 0x3800080}, +{0x3800000, 0x807fffff, 0xf51f853a, 0x751f853a, 0x3800080}, +{0x3800000, 0x807fffff, 0xff7ffff0, 0x7f7ffff0, 0x3800080}, +{0x3800000, 0x807fffff, 0xff7fffff, 0x7f7fffff, 0x3800080}, +{0x3800000, 0x807fffff, 0xff800000, 0x7f800000, 0x3800080}, +{0x3800000, 0x807fffff, 0xff800001, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0xff984a37, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0xffbfffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0x807fffff, 0xffc00000, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0xffd9ba98, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0xffffffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0x807fffff, 0x4f3495cb, 0xcf3495cb, 0x3800080}, +{0x3800000, 0x807fffff, 0xe73a5134, 0x673a5134, 0x3800080}, +{0x3800000, 0x807fffff, 0x7c994e9e, 0xfc994e9e, 0x3800080}, +{0x3800000, 0x807fffff, 0x6164bd6c, 0xe164bd6c, 0x3800080}, +{0x3800000, 0x807fffff, 0x9503366, 0x89503366, 0x3800080}, +{0x3800000, 0x807fffff, 0xbf5a97c9, 0x3f5a97c9, 0x3800080}, +{0x3800000, 0x807fffff, 0xe6ff1a14, 0x66ff1a14, 0x3800080}, +{0x3800000, 0x807fffff, 0x77f31e2f, 0xf7f31e2f, 0x3800080}, +{0x3800000, 0x807fffff, 0xaab4d7d8, 0x2ab4d7d8, 0x3800080}, +{0x3800000, 0x807fffff, 0x966320b, 0x8966320b, 0x3800080}, +{0x3800000, 0x807fffff, 0xb26bddee, 0x326bddee, 0x3800080}, +{0x3800000, 0x807fffff, 0xb5c8e5d3, 0x35c8e5d3, 0x3800080}, +{0x3800000, 0x807fffff, 0x317285d3, 0xb17285d3, 0x3800080}, +{0x3800000, 0x807fffff, 0x3c9623b1, 0xbc9623b1, 0x3800080}, +{0x3800000, 0x807fffff, 0x51fd2c7c, 0xd1fd2c7c, 0x3800080}, +{0x3800000, 0x807fffff, 0x7b906a6c, 0xfb906a6c, 0x3800080}, +{0x3800000, 0x80800000, 0x0, 0x80800000, 0x3800000}, +{0x3800000, 0x80800000, 0x1, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x76, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x2b94, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x636d24, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x7fffff, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x800000, 0x81000000, 0x3800000}, +{0x3800000, 0x80800000, 0x800002, 0x81000001, 0x3800000}, +{0x3800000, 0x80800000, 0x1398437, 0x81798437, 0x3800000}, +{0x3800000, 0x80800000, 0xba98d27, 0x8ba98d29, 0x3800000}, +{0x3800000, 0x80800000, 0xba98d7a, 0x8ba98d7c, 0x3800000}, +{0x3800000, 0x80800000, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0x80800000, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0x80800000, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0x80800000, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x80800000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0x80000000, 0x80800000, 0x3800000}, +{0x3800000, 0x80800000, 0x80000001, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x80000076, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x80002b94, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x80636d24, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x807fffff, 0x80800000, 0x3800080}, +{0x3800000, 0x80800000, 0x80800000, 0x80000000, 0x3800000}, +{0x3800000, 0x80800000, 0x80800002, 0x0, 0x3800008}, +{0x3800000, 0x80800000, 0x81398437, 0xf3086e, 0x3800000}, +{0x3800000, 0x80800000, 0x8ba98d27, 0xba98d25, 0x3800000}, +{0x3800000, 0x80800000, 0x8ba98d7a, 0xba98d78, 0x3800000}, +{0x3800000, 0x80800000, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0x80800000, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x80800000, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x80800000, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x80800000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800000, 0x4f3495cb, 0xcf3495cc, 0x3800010}, +{0x3800000, 0x80800000, 0xe73a5134, 0x673a5133, 0x3800010}, +{0x3800000, 0x80800000, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0x80800000, 0x6164bd6c, 0xe164bd6d, 0x3800010}, +{0x3800000, 0x80800000, 0x9503366, 0x895033a6, 0x3800000}, +{0x3800000, 0x80800000, 0xbf5a97c9, 0x3f5a97c8, 0x3800010}, +{0x3800000, 0x80800000, 0xe6ff1a14, 0x66ff1a13, 0x3800010}, +{0x3800000, 0x80800000, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0x80800000, 0xaab4d7d8, 0x2ab4d7d7, 0x3800010}, +{0x3800000, 0x80800000, 0x966320b, 0x8966324b, 0x3800000}, +{0x3800000, 0x80800000, 0xb26bddee, 0x326bdded, 0x3800010}, +{0x3800000, 0x80800000, 0xb5c8e5d3, 0x35c8e5d2, 0x3800010}, +{0x3800000, 0x80800000, 0x317285d3, 0xb17285d4, 0x3800010}, +{0x3800000, 0x80800000, 0x3c9623b1, 0xbc9623b2, 0x3800010}, +{0x3800000, 0x80800000, 0x51fd2c7c, 0xd1fd2c7d, 0x3800010}, +{0x3800000, 0x80800000, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0x80800002, 0x0, 0x80800002, 0x3800000}, +{0x3800000, 0x80800002, 0x1, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x76, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x2b94, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x636d24, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x7fffff, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x800000, 0x81000001, 0x3800000}, +{0x3800000, 0x80800002, 0x800002, 0x81000002, 0x3800000}, +{0x3800000, 0x80800002, 0x1398437, 0x81798438, 0x3800000}, +{0x3800000, 0x80800002, 0xba98d27, 0x8ba98d2a, 0x3800010}, +{0x3800000, 0x80800002, 0xba98d7a, 0x8ba98d7d, 0x3800010}, +{0x3800000, 0x80800002, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0x80800002, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0x80800002, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0x80800002, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x80800002, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0x80000000, 0x80800002, 0x3800000}, +{0x3800000, 0x80800002, 0x80000001, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x80000076, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x80002b94, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x80636d24, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x807fffff, 0x80800002, 0x3800080}, +{0x3800000, 0x80800002, 0x80800000, 0x0, 0x3800008}, +{0x3800000, 0x80800002, 0x80800002, 0x80000000, 0x3800000}, +{0x3800000, 0x80800002, 0x81398437, 0xf3086c, 0x3800000}, +{0x3800000, 0x80800002, 0x8ba98d27, 0xba98d24, 0x3800010}, +{0x3800000, 0x80800002, 0x8ba98d7a, 0xba98d77, 0x3800010}, +{0x3800000, 0x80800002, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0x80800002, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x80800002, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x80800002, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x80800002, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x80800002, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x80800002, 0x4f3495cb, 0xcf3495cc, 0x3800010}, +{0x3800000, 0x80800002, 0xe73a5134, 0x673a5133, 0x3800010}, +{0x3800000, 0x80800002, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0x80800002, 0x6164bd6c, 0xe164bd6d, 0x3800010}, +{0x3800000, 0x80800002, 0x9503366, 0x895033a7, 0x3800010}, +{0x3800000, 0x80800002, 0xbf5a97c9, 0x3f5a97c8, 0x3800010}, +{0x3800000, 0x80800002, 0xe6ff1a14, 0x66ff1a13, 0x3800010}, +{0x3800000, 0x80800002, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0x80800002, 0xaab4d7d8, 0x2ab4d7d7, 0x3800010}, +{0x3800000, 0x80800002, 0x966320b, 0x8966324c, 0x3800010}, +{0x3800000, 0x80800002, 0xb26bddee, 0x326bdded, 0x3800010}, +{0x3800000, 0x80800002, 0xb5c8e5d3, 0x35c8e5d2, 0x3800010}, +{0x3800000, 0x80800002, 0x317285d3, 0xb17285d4, 0x3800010}, +{0x3800000, 0x80800002, 0x3c9623b1, 0xbc9623b2, 0x3800010}, +{0x3800000, 0x80800002, 0x51fd2c7c, 0xd1fd2c7d, 0x3800010}, +{0x3800000, 0x80800002, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0x81398437, 0x0, 0x81398437, 0x3800000}, +{0x3800000, 0x81398437, 0x1, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x76, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x2b94, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x636d24, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x7fffff, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x800000, 0x81798437, 0x3800000}, +{0x3800000, 0x81398437, 0x800002, 0x81798438, 0x3800000}, +{0x3800000, 0x81398437, 0x1398437, 0x81b98437, 0x3800000}, +{0x3800000, 0x81398437, 0xba98d27, 0x8ba98d2d, 0x3800010}, +{0x3800000, 0x81398437, 0xba98d7a, 0x8ba98d80, 0x3800010}, +{0x3800000, 0x81398437, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0x81398437, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0x81398437, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0x81398437, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x81398437, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0x80000000, 0x81398437, 0x3800000}, +{0x3800000, 0x81398437, 0x80000001, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x80000076, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x80002b94, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x80636d24, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x807fffff, 0x81398437, 0x3800080}, +{0x3800000, 0x81398437, 0x80800000, 0x80f3086e, 0x3800000}, +{0x3800000, 0x81398437, 0x80800002, 0x80f3086c, 0x3800000}, +{0x3800000, 0x81398437, 0x81398437, 0x80000000, 0x3800000}, +{0x3800000, 0x81398437, 0x8ba98d27, 0xba98d21, 0x3800010}, +{0x3800000, 0x81398437, 0x8ba98d7a, 0xba98d74, 0x3800010}, +{0x3800000, 0x81398437, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0x81398437, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x81398437, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x81398437, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x81398437, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x81398437, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x81398437, 0x4f3495cb, 0xcf3495cc, 0x3800010}, +{0x3800000, 0x81398437, 0xe73a5134, 0x673a5133, 0x3800010}, +{0x3800000, 0x81398437, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0x81398437, 0x6164bd6c, 0xe164bd6d, 0x3800010}, +{0x3800000, 0x81398437, 0x9503366, 0x89503420, 0x3800010}, +{0x3800000, 0x81398437, 0xbf5a97c9, 0x3f5a97c8, 0x3800010}, +{0x3800000, 0x81398437, 0xe6ff1a14, 0x66ff1a13, 0x3800010}, +{0x3800000, 0x81398437, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0x81398437, 0xaab4d7d8, 0x2ab4d7d7, 0x3800010}, +{0x3800000, 0x81398437, 0x966320b, 0x896632c5, 0x3800010}, +{0x3800000, 0x81398437, 0xb26bddee, 0x326bdded, 0x3800010}, +{0x3800000, 0x81398437, 0xb5c8e5d3, 0x35c8e5d2, 0x3800010}, +{0x3800000, 0x81398437, 0x317285d3, 0xb17285d4, 0x3800010}, +{0x3800000, 0x81398437, 0x3c9623b1, 0xbc9623b2, 0x3800010}, +{0x3800000, 0x81398437, 0x51fd2c7c, 0xd1fd2c7d, 0x3800010}, +{0x3800000, 0x81398437, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x0, 0x8ba98d27, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x1, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x76, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x2b94, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x636d24, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x7fffff, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x800000, 0x8ba98d29, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x800002, 0x8ba98d2a, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x1398437, 0x8ba98d2d, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xba98d27, 0x8c298d27, 0x3800000}, +{0x3800000, 0x8ba98d27, 0xba98d7a, 0x8c298d51, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0x8ba98d27, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x80000000, 0x8ba98d27, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x80000001, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x80000076, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x80002b94, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x80636d24, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x807fffff, 0x8ba98d27, 0x3800080}, +{0x3800000, 0x8ba98d27, 0x80800000, 0x8ba98d25, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x80800002, 0x8ba98d25, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x81398437, 0x8ba98d22, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x8ba98d27, 0x80000000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x8ba98d7a, 0x3260000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d27, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d27, 0x4f3495cb, 0xcf3495cc, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xe73a5134, 0x673a5133, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x6164bd6c, 0xe164bd6d, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x9503366, 0x8bb00ec3, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xbf5a97c9, 0x3f5a97c8, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xe6ff1a14, 0x66ff1a13, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xaab4d7d8, 0x2ab4d7d7, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x966320b, 0x8bb0beb8, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xb26bddee, 0x326bdded, 0x3800010}, +{0x3800000, 0x8ba98d27, 0xb5c8e5d3, 0x35c8e5d2, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x317285d3, 0xb17285d4, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x3c9623b1, 0xbc9623b2, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x51fd2c7c, 0xd1fd2c7d, 0x3800010}, +{0x3800000, 0x8ba98d27, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x0, 0x8ba98d7a, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x1, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x76, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x2b94, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x636d24, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x7fffff, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x800000, 0x8ba98d7c, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x800002, 0x8ba98d7d, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x1398437, 0x8ba98d80, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xba98d27, 0x8c298d51, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xba98d7a, 0x8c298d7a, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0x8ba98d7a, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x80000000, 0x8ba98d7a, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x80000001, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x80000076, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x80002b94, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x80636d24, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x807fffff, 0x8ba98d7a, 0x3800080}, +{0x3800000, 0x8ba98d7a, 0x80800000, 0x8ba98d78, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x80800002, 0x8ba98d78, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x81398437, 0x8ba98d75, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x8ba98d27, 0x83260000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x8ba98d7a, 0x80000000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x8ba98d7a, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x8ba98d7a, 0x4f3495cb, 0xcf3495cc, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xe73a5134, 0x673a5133, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x6164bd6c, 0xe164bd6d, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x9503366, 0x8bb00f16, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xbf5a97c9, 0x3f5a97c8, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xe6ff1a14, 0x66ff1a13, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xaab4d7d8, 0x2ab4d7d7, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x966320b, 0x8bb0bf0b, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xb26bddee, 0x326bdded, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0xb5c8e5d3, 0x35c8e5d2, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x317285d3, 0xb17285d4, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x3c9623b1, 0xbc9623b2, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x51fd2c7c, 0xd1fd2c7d, 0x3800010}, +{0x3800000, 0x8ba98d7a, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0xf51f853a, 0x0, 0xf51f853a, 0x3800000}, +{0x3800000, 0xf51f853a, 0x1, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x76, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x2b94, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x636d24, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x7fffff, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x800000, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x800002, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x1398437, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0xba98d27, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0xba98d7a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x751f853a, 0xf59f853a, 0x3800000}, +{0x3800000, 0xf51f853a, 0x7f7ffff0, 0xff7ffffa, 0x3800010}, +{0x3800000, 0xf51f853a, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xf51f853a, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x80000000, 0xf51f853a, 0x3800000}, +{0x3800000, 0xf51f853a, 0x80000001, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x80000076, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x80002b94, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x80636d24, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x807fffff, 0xf51f853a, 0x3800080}, +{0x3800000, 0xf51f853a, 0x80800000, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x80800002, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x81398437, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x8ba98d27, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x8ba98d7a, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0xf51f853a, 0x80000000, 0x3800000}, +{0x3800000, 0xf51f853a, 0xff7ffff0, 0x7f7fffe6, 0x3800010}, +{0x3800000, 0xf51f853a, 0xff7fffff, 0x7f7ffff5, 0x3800010}, +{0x3800000, 0xf51f853a, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xf51f853a, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xf51f853a, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xf51f853a, 0x4f3495cb, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0xe73a5134, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x7c994e9e, 0xfc994fde, 0x3800010}, +{0x3800000, 0xf51f853a, 0x6164bd6c, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x9503366, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0xbf5a97c9, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0xe6ff1a14, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x77f31e2f, 0xf7f81a59, 0x3800010}, +{0x3800000, 0xf51f853a, 0xaab4d7d8, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x966320b, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0xb26bddee, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0xb5c8e5d3, 0xf51f853a, 0x3800010}, +{0x3800000, 0xf51f853a, 0x317285d3, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x3c9623b1, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x51fd2c7c, 0xf51f853b, 0x3800010}, +{0x3800000, 0xf51f853a, 0x7b906a6c, 0xfb906f69, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x0, 0xff7ffff0, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x1, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x76, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x2b94, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x636d24, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x7fffff, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x800000, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x800002, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x1398437, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xba98d27, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xba98d7a, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x751f853a, 0xff7ffffa, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x7f7ffff0, 0xff800000, 0x3800014}, +{0x3800000, 0xff7ffff0, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xff7ffff0, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x80000000, 0xff7ffff0, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x80000001, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x80000076, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x80002b94, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x80636d24, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x807fffff, 0xff7ffff0, 0x3800080}, +{0x3800000, 0xff7ffff0, 0x80800000, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x80800002, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x81398437, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x8ba98d27, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x8ba98d7a, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xf51f853a, 0xff7fffe7, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xff7ffff0, 0x80000000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0xff7fffff, 0x75700000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7ffff0, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7ffff0, 0x4f3495cb, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xe73a5134, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x7c994e9e, 0xff800000, 0x3800014}, +{0x3800000, 0xff7ffff0, 0x6164bd6c, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x9503366, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xbf5a97c9, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xe6ff1a14, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x77f31e2f, 0xff800000, 0x3800014}, +{0x3800000, 0xff7ffff0, 0xaab4d7d8, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x966320b, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xb26bddee, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0xb5c8e5d3, 0xff7ffff0, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x317285d3, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x3c9623b1, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x51fd2c7c, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xff7ffff0, 0x7b906a6c, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x0, 0xff7fffff, 0x3800000}, +{0x3800000, 0xff7fffff, 0x1, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x76, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x2b94, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x636d24, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x7fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x800000, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x800002, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x1398437, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xba98d27, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xba98d7a, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x751f853a, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x7f7ffff0, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x80000000, 0xff7fffff, 0x3800000}, +{0x3800000, 0xff7fffff, 0x80000001, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x80000076, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x80002b94, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x80636d24, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x807fffff, 0xff7fffff, 0x3800080}, +{0x3800000, 0xff7fffff, 0x80800000, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x80800002, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x81398437, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x8ba98d27, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x8ba98d7a, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0xf51f853a, 0xff7ffff6, 0x3800010}, +{0x3800000, 0xff7fffff, 0xff7ffff0, 0xf5700000, 0x3800000}, +{0x3800000, 0xff7fffff, 0xff7fffff, 0x80000000, 0x3800000}, +{0x3800000, 0xff7fffff, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xff7fffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff7fffff, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff7fffff, 0x4f3495cb, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xe73a5134, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x7c994e9e, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x6164bd6c, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x9503366, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xbf5a97c9, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0xe6ff1a14, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x77f31e2f, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xaab4d7d8, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x966320b, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0xb26bddee, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0xb5c8e5d3, 0xff7fffff, 0x3800010}, +{0x3800000, 0xff7fffff, 0x317285d3, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x3c9623b1, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x51fd2c7c, 0xff800000, 0x3800014}, +{0x3800000, 0xff7fffff, 0x7b906a6c, 0xff800000, 0x3800014}, +{0x3800000, 0xff800000, 0x0, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x1, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x76, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x2b94, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x636d24, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x7fffff, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x800000, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x800002, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x1398437, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xba98d27, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xba98d7a, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x751f853a, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7f7ffff0, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7f7fffff, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0x80000000, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x80000001, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x80000076, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x80002b94, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x80636d24, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x807fffff, 0xff800000, 0x3800080}, +{0x3800000, 0xff800000, 0x80800000, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x80800002, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x81398437, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x8ba98d27, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x8ba98d7a, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xf51f853a, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xff7ffff0, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xff7fffff, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xff800000, 0x4f3495cb, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xe73a5134, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7c994e9e, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x6164bd6c, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x9503366, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xbf5a97c9, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xe6ff1a14, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x77f31e2f, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xaab4d7d8, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x966320b, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xb26bddee, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0xb5c8e5d3, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x317285d3, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x3c9623b1, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x51fd2c7c, 0xff800000, 0x3800000}, +{0x3800000, 0xff800000, 0x7b906a6c, 0xff800000, 0x3800000}, +{0x3800000, 0xff800001, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff800001, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff800001, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xff984a37, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xff984a37, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x1, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x76, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x2b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x7fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x1398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x751f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7f7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7f7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7f800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7fc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7fd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7fffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x80000000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x80000001, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x80000076, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x80002b94, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x80636d24, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x807fffff, 0x7fc00000, 0x3800081}, +{0x3800000, 0xffbfffff, 0x80800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x80800002, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x81398437, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x8ba98d27, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x8ba98d7a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xf51f853a, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xff7ffff0, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xff7fffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xff800000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xffc00000, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xffd9ba98, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xffffffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x4f3495cb, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xe73a5134, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7c994e9e, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x6164bd6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x9503366, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xbf5a97c9, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xe6ff1a14, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x77f31e2f, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xaab4d7d8, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x966320b, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xb26bddee, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x317285d3, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x3c9623b1, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x51fd2c7c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffbfffff, 0x7b906a6c, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffc00000, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffc00000, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffc00000, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffd9ba98, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffd9ba98, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffd9ba98, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x1, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x76, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x2b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x7fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x1398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x751f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7f7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7f7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7f800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x80000000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x80000001, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x80000076, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x80002b94, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x80636d24, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x807fffff, 0x7fc00000, 0x3800080}, +{0x3800000, 0xffffffff, 0x80800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x80800002, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x81398437, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x8ba98d27, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x8ba98d7a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xf51f853a, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xff7ffff0, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xff7fffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xff800000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xffffffff, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x4f3495cb, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xe73a5134, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7c994e9e, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x6164bd6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x9503366, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xbf5a97c9, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xe6ff1a14, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x77f31e2f, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xaab4d7d8, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x966320b, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xb26bddee, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0xb5c8e5d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x317285d3, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x3c9623b1, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x51fd2c7c, 0x7fc00000, 0x3800000}, +{0x3800000, 0xffffffff, 0x7b906a6c, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x0, 0x4f3495cb, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x1, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x76, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x2b94, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x636d24, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x7fffff, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x800000, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x800002, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x1398437, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xba98d27, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xba98d7a, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x80000000, 0x4f3495cb, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x80000001, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x80000076, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x80002b94, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x80636d24, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x807fffff, 0x4f3495cb, 0x3800080}, +{0x3800000, 0x4f3495cb, 0x80800000, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x80800002, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x81398437, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x8ba98d27, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x8ba98d7a, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x4f3495cb, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0x4f3495cb, 0x80000000, 0x3800000}, +{0x3800000, 0x4f3495cb, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x9503366, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xbf5a97c9, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xaab4d7d8, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x966320b, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xb26bddee, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0xb5c8e5d3, 0x4f3495cb, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x317285d3, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x3c9623b1, 0x4f3495ca, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x51fd2c7c, 0xd1f787ce, 0x3800010}, +{0x3800000, 0x4f3495cb, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0xe73a5134, 0x0, 0xe73a5134, 0x3800000}, +{0x3800000, 0xe73a5134, 0x1, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x76, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x2b94, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x636d24, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x7fffff, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x800000, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x800002, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x1398437, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0xba98d27, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0xba98d7a, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xe73a5134, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xe73a5134, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xe73a5134, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x80000000, 0xe73a5134, 0x3800000}, +{0x3800000, 0xe73a5134, 0x80000001, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x80000076, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x80002b94, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x80636d24, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x807fffff, 0xe73a5134, 0x3800080}, +{0x3800000, 0xe73a5134, 0x80800000, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x80800002, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x81398437, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x8ba98d27, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x8ba98d7a, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xe73a5134, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xe73a5134, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xe73a5134, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xe73a5134, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe73a5134, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x4f3495cb, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0xe73a5134, 0x80000000, 0x3800000}, +{0x3800000, 0xe73a5134, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0xe73a5134, 0x6164bd6c, 0xe73a5f80, 0x3800010}, +{0x3800000, 0xe73a5134, 0x9503366, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0xbf5a97c9, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0xe6ff1a14, 0xe66b10a8, 0x3800000}, +{0x3800000, 0xe73a5134, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0xe73a5134, 0xaab4d7d8, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x966320b, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0xb26bddee, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0xb5c8e5d3, 0xe73a5134, 0x3800010}, +{0x3800000, 0xe73a5134, 0x317285d3, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x3c9623b1, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x51fd2c7c, 0xe73a5135, 0x3800010}, +{0x3800000, 0xe73a5134, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x0, 0x7c994e9e, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x1, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x76, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x2b94, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x636d24, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x7fffff, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x800000, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x800002, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x1398437, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xba98d27, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xba98d7a, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x751f853a, 0x7c994d5e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x7f7ffff0, 0xff7b357c, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x7f7fffff, 0xff7b358b, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x80000000, 0x7c994e9e, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x80000001, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x80000076, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x80002b94, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x80636d24, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x807fffff, 0x7c994e9e, 0x3800080}, +{0x3800000, 0x7c994e9e, 0x80800000, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x80800002, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x81398437, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x8ba98d27, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x8ba98d7a, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xf51f853a, 0x7c994fdd, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xff7ffff0, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7c994e9e, 0xff7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7c994e9e, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7c994e9e, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x4f3495cb, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xe73a5134, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x7c994e9e, 0x80000000, 0x3800000}, +{0x3800000, 0x7c994e9e, 0x6164bd6c, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x9503366, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xbf5a97c9, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xe6ff1a14, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x77f31e2f, 0x7c9911d6, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xaab4d7d8, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x966320b, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xb26bddee, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0xb5c8e5d3, 0x7c994e9e, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x317285d3, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x3c9623b1, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x51fd2c7c, 0x7c994e9d, 0x3800010}, +{0x3800000, 0x7c994e9e, 0x7b906a6c, 0x7c6a6806, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x0, 0x6164bd6c, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x1, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x76, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x2b94, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x636d24, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x7fffff, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x800000, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x800002, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x1398437, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xba98d27, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xba98d7a, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x80000000, 0x6164bd6c, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x80000001, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x80000076, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x80002b94, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x80636d24, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x807fffff, 0x6164bd6c, 0x3800080}, +{0x3800000, 0x6164bd6c, 0x80800000, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x80800002, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x81398437, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x8ba98d27, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x8ba98d7a, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x6164bd6c, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x4f3495cb, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xe73a5134, 0x673a5f7f, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x6164bd6c, 0x80000000, 0x3800000}, +{0x3800000, 0x6164bd6c, 0x9503366, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xbf5a97c9, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xe6ff1a14, 0x66ff36ab, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xaab4d7d8, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x966320b, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xb26bddee, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0xb5c8e5d3, 0x6164bd6c, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x317285d3, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x3c9623b1, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x51fd2c7c, 0x6164bd6b, 0x3800010}, +{0x3800000, 0x6164bd6c, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0x9503366, 0x0, 0x9503366, 0x3800000}, +{0x3800000, 0x9503366, 0x1, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x76, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x2b94, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x636d24, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x7fffff, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x800000, 0x9503326, 0x3800000}, +{0x3800000, 0x9503366, 0x800002, 0x9503325, 0x3800010}, +{0x3800000, 0x9503366, 0x1398437, 0x95032ac, 0x3800010}, +{0x3800000, 0x9503366, 0xba98d27, 0x8ba30b8c, 0x3800010}, +{0x3800000, 0x9503366, 0xba98d7a, 0x8ba30bdf, 0x3800010}, +{0x3800000, 0x9503366, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x9503366, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x9503366, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x9503366, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x9503366, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0x80000000, 0x9503366, 0x3800000}, +{0x3800000, 0x9503366, 0x80000001, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x80000076, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x80002b94, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x80636d24, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x807fffff, 0x9503366, 0x3800080}, +{0x3800000, 0x9503366, 0x80800000, 0x95033a6, 0x3800000}, +{0x3800000, 0x9503366, 0x80800002, 0x95033a6, 0x3800010}, +{0x3800000, 0x9503366, 0x81398437, 0x950341f, 0x3800010}, +{0x3800000, 0x9503366, 0x8ba98d27, 0xbb00ec2, 0x3800010}, +{0x3800000, 0x9503366, 0x8ba98d7a, 0xbb00f15, 0x3800010}, +{0x3800000, 0x9503366, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x9503366, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x9503366, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x9503366, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x9503366, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x9503366, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x9503366, 0x4f3495cb, 0xcf3495cb, 0x3800010}, +{0x3800000, 0x9503366, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0x9503366, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0x9503366, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0x9503366, 0x9503366, 0x80000000, 0x3800000}, +{0x3800000, 0x9503366, 0xbf5a97c9, 0x3f5a97c9, 0x3800010}, +{0x3800000, 0x9503366, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0x9503366, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0x9503366, 0xaab4d7d8, 0x2ab4d7d8, 0x3800010}, +{0x3800000, 0x9503366, 0x966320b, 0x87aff528, 0x3800000}, +{0x3800000, 0x9503366, 0xb26bddee, 0x326bddee, 0x3800010}, +{0x3800000, 0x9503366, 0xb5c8e5d3, 0x35c8e5d3, 0x3800010}, +{0x3800000, 0x9503366, 0x317285d3, 0xb17285d3, 0x3800010}, +{0x3800000, 0x9503366, 0x3c9623b1, 0xbc9623b1, 0x3800010}, +{0x3800000, 0x9503366, 0x51fd2c7c, 0xd1fd2c7c, 0x3800010}, +{0x3800000, 0x9503366, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x0, 0xbf5a97c9, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x1, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x76, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x2b94, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x636d24, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x7fffff, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x800000, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x800002, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x1398437, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xba98d27, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xba98d7a, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xbf5a97c9, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x80000000, 0xbf5a97c9, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x80000001, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x80000076, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x80002b94, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x80636d24, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x807fffff, 0xbf5a97c9, 0x3800080}, +{0x3800000, 0xbf5a97c9, 0x80800000, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x80800002, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x81398437, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x8ba98d27, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x8ba98d7a, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xbf5a97c9, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0x4f3495cb, 0xcf3495cc, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xe73a5134, 0x673a5133, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x6164bd6c, 0xe164bd6d, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x9503366, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xbf5a97c9, 0x80000000, 0x3800000}, +{0x3800000, 0xbf5a97c9, 0xe6ff1a14, 0x66ff1a13, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xaab4d7d8, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x966320b, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xb26bddee, 0xbf5a97c9, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0xb5c8e5d3, 0xbf5a97b0, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x317285d3, 0xbf5a97ca, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x3c9623b1, 0xbf5f48e7, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x51fd2c7c, 0xd1fd2c7d, 0x3800010}, +{0x3800000, 0xbf5a97c9, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x0, 0xe6ff1a14, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x1, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x76, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x2b94, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x636d24, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x7fffff, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x800000, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x800002, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x1398437, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xba98d27, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xba98d7a, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xe6ff1a14, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x80000000, 0xe6ff1a14, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x80000001, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x80000076, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x80002b94, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x80636d24, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x807fffff, 0xe6ff1a14, 0x3800080}, +{0x3800000, 0xe6ff1a14, 0x80800000, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x80800002, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x81398437, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x8ba98d27, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x8ba98d7a, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xe6ff1a14, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x4f3495cb, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xe73a5134, 0x666b10a8, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x6164bd6c, 0xe6ff36ac, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x9503366, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xbf5a97c9, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xe6ff1a14, 0x80000000, 0x3800000}, +{0x3800000, 0xe6ff1a14, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xaab4d7d8, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x966320b, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xb26bddee, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0xb5c8e5d3, 0xe6ff1a14, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x317285d3, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x3c9623b1, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x51fd2c7c, 0xe6ff1a15, 0x3800010}, +{0x3800000, 0xe6ff1a14, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x0, 0x77f31e2f, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x1, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x76, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x2b94, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x636d24, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x7fffff, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x800000, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x800002, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x1398437, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xba98d27, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xba98d7a, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x751f853a, 0x77ee2205, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x7f7ffff0, 0xff7ffe0a, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x7f7fffff, 0xff7ffe19, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x80000000, 0x77f31e2f, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x80000001, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x80000076, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x80002b94, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x80636d24, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x807fffff, 0x77f31e2f, 0x3800080}, +{0x3800000, 0x77f31e2f, 0x80800000, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x80800002, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x81398437, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x8ba98d27, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x8ba98d7a, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xf51f853a, 0x77f81a58, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xff7ffff0, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x77f31e2f, 0xff7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x77f31e2f, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x77f31e2f, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0x4f3495cb, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xe73a5134, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x7c994e9e, 0xfc9911d7, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x6164bd6c, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x9503366, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xbf5a97c9, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xe6ff1a14, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x77f31e2f, 0x80000000, 0x3800000}, +{0x3800000, 0x77f31e2f, 0xaab4d7d8, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x966320b, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xb26bddee, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0xb5c8e5d3, 0x77f31e2f, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x317285d3, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x3c9623b1, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x51fd2c7c, 0x77f31e2e, 0x3800010}, +{0x3800000, 0x77f31e2f, 0x7b906a6c, 0xfb8f774e, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x0, 0xaab4d7d8, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x1, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x76, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x2b94, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x636d24, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x7fffff, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x800000, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x800002, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x1398437, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xba98d27, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xba98d7a, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xaab4d7d8, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x80000000, 0xaab4d7d8, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x80000001, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x80000076, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x80002b94, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x80636d24, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x807fffff, 0xaab4d7d8, 0x3800080}, +{0x3800000, 0xaab4d7d8, 0x80800000, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x80800002, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x81398437, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x8ba98d27, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x8ba98d7a, 0xaab4d7d8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xaab4d7d8, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x4f3495cb, 0xcf3495cc, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xe73a5134, 0x673a5133, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x6164bd6c, 0xe164bd6d, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x9503366, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xbf5a97c9, 0x3f5a97c8, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xe6ff1a14, 0x66ff1a13, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xaab4d7d8, 0x80000000, 0x3800000}, +{0x3800000, 0xaab4d7d8, 0x966320b, 0xaab4d7d9, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xb26bddee, 0x326bdc84, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0xb5c8e5d3, 0x35c8e5d0, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x317285d3, 0xb1728b7a, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x3c9623b1, 0xbc9623b2, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x51fd2c7c, 0xd1fd2c7d, 0x3800010}, +{0x3800000, 0xaab4d7d8, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0x966320b, 0x0, 0x966320b, 0x3800000}, +{0x3800000, 0x966320b, 0x1, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x76, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x2b94, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x636d24, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x7fffff, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x800000, 0x96631cb, 0x3800000}, +{0x3800000, 0x966320b, 0x800002, 0x96631ca, 0x3800010}, +{0x3800000, 0x966320b, 0x1398437, 0x9663151, 0x3800010}, +{0x3800000, 0x966320b, 0xba98d27, 0x8ba25b97, 0x3800010}, +{0x3800000, 0x966320b, 0xba98d7a, 0x8ba25bea, 0x3800010}, +{0x3800000, 0x966320b, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x966320b, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x966320b, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x966320b, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x966320b, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0x80000000, 0x966320b, 0x3800000}, +{0x3800000, 0x966320b, 0x80000001, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x80000076, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x80002b94, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x80636d24, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x807fffff, 0x966320b, 0x3800080}, +{0x3800000, 0x966320b, 0x80800000, 0x966324b, 0x3800000}, +{0x3800000, 0x966320b, 0x80800002, 0x966324b, 0x3800010}, +{0x3800000, 0x966320b, 0x81398437, 0x96632c4, 0x3800010}, +{0x3800000, 0x966320b, 0x8ba98d27, 0xbb0beb7, 0x3800010}, +{0x3800000, 0x966320b, 0x8ba98d7a, 0xbb0bf0a, 0x3800010}, +{0x3800000, 0x966320b, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x966320b, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x966320b, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x966320b, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x966320b, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x966320b, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x966320b, 0x4f3495cb, 0xcf3495cb, 0x3800010}, +{0x3800000, 0x966320b, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0x966320b, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0x966320b, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0x966320b, 0x9503366, 0x7aff528, 0x3800000}, +{0x3800000, 0x966320b, 0xbf5a97c9, 0x3f5a97c9, 0x3800010}, +{0x3800000, 0x966320b, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0x966320b, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0x966320b, 0xaab4d7d8, 0x2ab4d7d8, 0x3800010}, +{0x3800000, 0x966320b, 0x966320b, 0x80000000, 0x3800000}, +{0x3800000, 0x966320b, 0xb26bddee, 0x326bddee, 0x3800010}, +{0x3800000, 0x966320b, 0xb5c8e5d3, 0x35c8e5d3, 0x3800010}, +{0x3800000, 0x966320b, 0x317285d3, 0xb17285d3, 0x3800010}, +{0x3800000, 0x966320b, 0x3c9623b1, 0xbc9623b1, 0x3800010}, +{0x3800000, 0x966320b, 0x51fd2c7c, 0xd1fd2c7c, 0x3800010}, +{0x3800000, 0x966320b, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0xb26bddee, 0x0, 0xb26bddee, 0x3800000}, +{0x3800000, 0xb26bddee, 0x1, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x76, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x2b94, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x636d24, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x7fffff, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x800000, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0x800002, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0x1398437, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0xba98d27, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0xba98d7a, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xb26bddee, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xb26bddee, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xb26bddee, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xb26bddee, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0x80000000, 0xb26bddee, 0x3800000}, +{0x3800000, 0xb26bddee, 0x80000001, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x80000076, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x80002b94, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x80636d24, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x807fffff, 0xb26bddee, 0x3800080}, +{0x3800000, 0xb26bddee, 0x80800000, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0x80800002, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0x81398437, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0x8ba98d27, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0x8ba98d7a, 0xb26bddee, 0x3800010}, +{0x3800000, 0xb26bddee, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xb26bddee, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xb26bddee, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xb26bddee, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xb26bddee, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb26bddee, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb26bddee, 0x4f3495cb, 0xcf3495cc, 0x3800010}, +{0x3800000, 0xb26bddee, 0xe73a5134, 0x673a5133, 0x3800010}, +{0x3800000, 0xb26bddee, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0xb26bddee, 0x6164bd6c, 0xe164bd6d, 0x3800010}, +{0x3800000, 0xb26bddee, 0x9503366, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0xbf5a97c9, 0x3f5a97c8, 0x3800010}, +{0x3800000, 0xb26bddee, 0xe6ff1a14, 0x66ff1a13, 0x3800010}, +{0x3800000, 0xb26bddee, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0xb26bddee, 0xaab4d7d8, 0xb26bdc85, 0x3800010}, +{0x3800000, 0xb26bddee, 0x966320b, 0xb26bddef, 0x3800010}, +{0x3800000, 0xb26bddee, 0xb26bddee, 0x80000000, 0x3800000}, +{0x3800000, 0xb26bddee, 0xb5c8e5d3, 0x35c70e17, 0x3800010}, +{0x3800000, 0xb26bddee, 0x317285d3, 0xb2943fb2, 0x3800010}, +{0x3800000, 0xb26bddee, 0x3c9623b1, 0xbc9623b9, 0x3800010}, +{0x3800000, 0xb26bddee, 0x51fd2c7c, 0xd1fd2c7d, 0x3800010}, +{0x3800000, 0xb26bddee, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x0, 0xb5c8e5d3, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x1, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x76, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x2b94, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x636d24, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x7fffff, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x800000, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x800002, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x1398437, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xba98d27, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xba98d7a, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x751f853a, 0xf51f853b, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x7f7ffff0, 0xff7ffff1, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x7f7fffff, 0xff800000, 0x3800014}, +{0x3800000, 0xb5c8e5d3, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x80000000, 0xb5c8e5d3, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x80000001, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x80000076, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x80002b94, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x80636d24, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x807fffff, 0xb5c8e5d3, 0x3800080}, +{0x3800000, 0xb5c8e5d3, 0x80800000, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x80800002, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x81398437, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x8ba98d27, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x8ba98d7a, 0xb5c8e5d3, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xf51f853a, 0x751f8539, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xff7ffff0, 0x7f7fffef, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xff7fffff, 0x7f7ffffe, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0xb5c8e5d3, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x4f3495cb, 0xcf3495cc, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xe73a5134, 0x673a5133, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x7c994e9e, 0xfc994e9f, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x6164bd6c, 0xe164bd6d, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x9503366, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xbf5a97c9, 0x3f5a97af, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xe6ff1a14, 0x66ff1a13, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x77f31e2f, 0xf7f31e30, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xaab4d7d8, 0xb5c8e5d1, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x966320b, 0xb5c8e5d4, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xb26bddee, 0xb5c70e18, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0xb5c8e5d3, 0x80000000, 0x3800000}, +{0x3800000, 0xb5c8e5d3, 0x317285d3, 0xb5c95f16, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x3c9623b1, 0xbc9626d5, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x51fd2c7c, 0xd1fd2c7d, 0x3800010}, +{0x3800000, 0xb5c8e5d3, 0x7b906a6c, 0xfb906a6d, 0x3800010}, +{0x3800000, 0x317285d3, 0x0, 0x317285d3, 0x3800000}, +{0x3800000, 0x317285d3, 0x1, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x76, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x2b94, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x636d24, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x7fffff, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x800000, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0x800002, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0x1398437, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0xba98d27, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0xba98d7a, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x317285d3, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x317285d3, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x317285d3, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x317285d3, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0x80000000, 0x317285d3, 0x3800000}, +{0x3800000, 0x317285d3, 0x80000001, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x80000076, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x80002b94, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x80636d24, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x807fffff, 0x317285d3, 0x3800080}, +{0x3800000, 0x317285d3, 0x80800000, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0x80800002, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0x81398437, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0x8ba98d27, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0x8ba98d7a, 0x317285d3, 0x3800010}, +{0x3800000, 0x317285d3, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x317285d3, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x317285d3, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x317285d3, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x317285d3, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x317285d3, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x317285d3, 0x4f3495cb, 0xcf3495cb, 0x3800010}, +{0x3800000, 0x317285d3, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0x317285d3, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0x317285d3, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0x317285d3, 0x9503366, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0xbf5a97c9, 0x3f5a97c9, 0x3800010}, +{0x3800000, 0x317285d3, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0x317285d3, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0x317285d3, 0xaab4d7d8, 0x31728b79, 0x3800010}, +{0x3800000, 0x317285d3, 0x966320b, 0x317285d2, 0x3800010}, +{0x3800000, 0x317285d3, 0xb26bddee, 0x32943fb1, 0x3800010}, +{0x3800000, 0x317285d3, 0xb5c8e5d3, 0x35c95f15, 0x3800010}, +{0x3800000, 0x317285d3, 0x317285d3, 0x80000000, 0x3800000}, +{0x3800000, 0x317285d3, 0x3c9623b1, 0xbc9623b0, 0x3800010}, +{0x3800000, 0x317285d3, 0x51fd2c7c, 0xd1fd2c7c, 0x3800010}, +{0x3800000, 0x317285d3, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x0, 0x3c9623b1, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x1, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x76, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x2b94, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x636d24, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x7fffff, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x800000, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x800002, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x1398437, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xba98d27, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xba98d7a, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x80000000, 0x3c9623b1, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x80000001, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x80000076, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x80002b94, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x80636d24, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x807fffff, 0x3c9623b1, 0x3800080}, +{0x3800000, 0x3c9623b1, 0x80800000, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x80800002, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x81398437, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x8ba98d27, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x8ba98d7a, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x3c9623b1, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x4f3495cb, 0xcf3495cb, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x9503366, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xbf5a97c9, 0x3f5f48e6, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xaab4d7d8, 0x3c9623b1, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x966320b, 0x3c9623b0, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xb26bddee, 0x3c9623b8, 0x3800010}, +{0x3800000, 0x3c9623b1, 0xb5c8e5d3, 0x3c9626d4, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x317285d3, 0x3c9623af, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x3c9623b1, 0x80000000, 0x3800000}, +{0x3800000, 0x3c9623b1, 0x51fd2c7c, 0xd1fd2c7c, 0x3800010}, +{0x3800000, 0x3c9623b1, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x0, 0x51fd2c7c, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x1, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x76, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x2b94, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x636d24, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x7fffff, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x800000, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x800002, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x1398437, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xba98d27, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xba98d7a, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x751f853a, 0xf51f853a, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x7f7ffff0, 0xff7ffff0, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x7f7fffff, 0xff7fffff, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x80000000, 0x51fd2c7c, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x80000001, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x80000076, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x80002b94, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x80636d24, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x807fffff, 0x51fd2c7c, 0x3800080}, +{0x3800000, 0x51fd2c7c, 0x80800000, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x80800002, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x81398437, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x8ba98d27, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x8ba98d7a, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xf51f853a, 0x751f853a, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xff7ffff0, 0x7f7ffff0, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xff7fffff, 0x7f7fffff, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x51fd2c7c, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x4f3495cb, 0x51f787cd, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xe73a5134, 0x673a5134, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x7c994e9e, 0xfc994e9e, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x6164bd6c, 0xe164bd6c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x9503366, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xbf5a97c9, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xe6ff1a14, 0x66ff1a14, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x77f31e2f, 0xf7f31e2f, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xaab4d7d8, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x966320b, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xb26bddee, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0xb5c8e5d3, 0x51fd2c7c, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x317285d3, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x3c9623b1, 0x51fd2c7b, 0x3800010}, +{0x3800000, 0x51fd2c7c, 0x51fd2c7c, 0x80000000, 0x3800000}, +{0x3800000, 0x51fd2c7c, 0x7b906a6c, 0xfb906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x0, 0x7b906a6c, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x1, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x76, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x2b94, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x636d24, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x7fffff, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x800000, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x800002, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x1398437, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xba98d27, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xba98d7a, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x751f853a, 0x7b90656f, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x7f7ffff0, 0xff7edf1c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x7f7fffff, 0xff7edf2b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x7f800000, 0xff800000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x7f800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0x7f984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0x7fbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0x7fc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x7fd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x7fffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x80000000, 0x7b906a6c, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x80000001, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x80000076, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x80002b94, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x80636d24, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x807fffff, 0x7b906a6c, 0x3800080}, +{0x3800000, 0x7b906a6c, 0x80800000, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x80800002, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x81398437, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x8ba98d27, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x8ba98d7a, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xf51f853a, 0x7b906f68, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xff7ffff0, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7b906a6c, 0xff7fffff, 0x7f7fffff, 0x3800014}, +{0x3800000, 0x7b906a6c, 0xff800000, 0x7f800000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0xff800001, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0xff984a37, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0xffbfffff, 0x7fc00000, 0x3800001}, +{0x3800000, 0x7b906a6c, 0xffc00000, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0xffd9ba98, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0xffffffff, 0x7fc00000, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x4f3495cb, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xe73a5134, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x7c994e9e, 0xfc6a6806, 0x3800000}, +{0x3800000, 0x7b906a6c, 0x6164bd6c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x9503366, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xbf5a97c9, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xe6ff1a14, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x77f31e2f, 0x7b8f774d, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xaab4d7d8, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x966320b, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xb26bddee, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0xb5c8e5d3, 0x7b906a6c, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x317285d3, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x3c9623b1, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x51fd2c7c, 0x7b906a6b, 0x3800010}, +{0x3800000, 0x7b906a6c, 0x7b906a6c, 0x80000000, 0x3800000}, +{0x3400000, 0x0, 0x0, 0x0, 0x3400000}, +{0x3400000, 0x0, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x800000, 0x80800000, 0x3400000}, +{0x3400000, 0x0, 0x800002, 0x80800002, 0x3400000}, +{0x3400000, 0x0, 0x1398437, 0x81398437, 0x3400000}, +{0x3400000, 0x0, 0xba98d27, 0x8ba98d27, 0x3400000}, +{0x3400000, 0x0, 0xba98d7a, 0x8ba98d7a, 0x3400000}, +{0x3400000, 0x0, 0x751f853a, 0xf51f853a, 0x3400000}, +{0x3400000, 0x0, 0x7f7ffff0, 0xff7ffff0, 0x3400000}, +{0x3400000, 0x0, 0x7f7fffff, 0xff7fffff, 0x3400000}, +{0x3400000, 0x0, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x0, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0x80000000, 0x0, 0x3400000}, +{0x3400000, 0x0, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x0, 0x80800000, 0x800000, 0x3400000}, +{0x3400000, 0x0, 0x80800002, 0x800002, 0x3400000}, +{0x3400000, 0x0, 0x81398437, 0x1398437, 0x3400000}, +{0x3400000, 0x0, 0x8ba98d27, 0xba98d27, 0x3400000}, +{0x3400000, 0x0, 0x8ba98d7a, 0xba98d7a, 0x3400000}, +{0x3400000, 0x0, 0xf51f853a, 0x751f853a, 0x3400000}, +{0x3400000, 0x0, 0xff7ffff0, 0x7f7ffff0, 0x3400000}, +{0x3400000, 0x0, 0xff7fffff, 0x7f7fffff, 0x3400000}, +{0x3400000, 0x0, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x0, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x0, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x0, 0x4f3495cb, 0xcf3495cb, 0x3400000}, +{0x3400000, 0x0, 0xe73a5134, 0x673a5134, 0x3400000}, +{0x3400000, 0x0, 0x7c994e9e, 0xfc994e9e, 0x3400000}, +{0x3400000, 0x0, 0x6164bd6c, 0xe164bd6c, 0x3400000}, +{0x3400000, 0x0, 0x9503366, 0x89503366, 0x3400000}, +{0x3400000, 0x0, 0xbf5a97c9, 0x3f5a97c9, 0x3400000}, +{0x3400000, 0x0, 0xe6ff1a14, 0x66ff1a14, 0x3400000}, +{0x3400000, 0x0, 0x77f31e2f, 0xf7f31e2f, 0x3400000}, +{0x3400000, 0x0, 0xaab4d7d8, 0x2ab4d7d8, 0x3400000}, +{0x3400000, 0x0, 0x966320b, 0x8966320b, 0x3400000}, +{0x3400000, 0x0, 0xb26bddee, 0x326bddee, 0x3400000}, +{0x3400000, 0x0, 0xb5c8e5d3, 0x35c8e5d3, 0x3400000}, +{0x3400000, 0x0, 0x317285d3, 0xb17285d3, 0x3400000}, +{0x3400000, 0x0, 0x3c9623b1, 0xbc9623b1, 0x3400000}, +{0x3400000, 0x0, 0x51fd2c7c, 0xd1fd2c7c, 0x3400000}, +{0x3400000, 0x0, 0x7b906a6c, 0xfb906a6c, 0x3400000}, +{0x3400000, 0x1, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x800000, 0x80800000, 0x3400080}, +{0x3400000, 0x1, 0x800002, 0x80800002, 0x3400080}, +{0x3400000, 0x1, 0x1398437, 0x81398437, 0x3400080}, +{0x3400000, 0x1, 0xba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x1, 0xba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x1, 0x751f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x1, 0x7f7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x1, 0x7f7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x1, 0x7f800000, 0xff800000, 0x3400080}, +{0x3400000, 0x1, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x1, 0x80800000, 0x800000, 0x3400080}, +{0x3400000, 0x1, 0x80800002, 0x800002, 0x3400080}, +{0x3400000, 0x1, 0x81398437, 0x1398437, 0x3400080}, +{0x3400000, 0x1, 0x8ba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x1, 0x8ba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x1, 0xf51f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x1, 0xff7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x1, 0xff7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x1, 0xff800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x1, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x1, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x1, 0x4f3495cb, 0xcf3495cb, 0x3400080}, +{0x3400000, 0x1, 0xe73a5134, 0x673a5134, 0x3400080}, +{0x3400000, 0x1, 0x7c994e9e, 0xfc994e9e, 0x3400080}, +{0x3400000, 0x1, 0x6164bd6c, 0xe164bd6c, 0x3400080}, +{0x3400000, 0x1, 0x9503366, 0x89503366, 0x3400080}, +{0x3400000, 0x1, 0xbf5a97c9, 0x3f5a97c9, 0x3400080}, +{0x3400000, 0x1, 0xe6ff1a14, 0x66ff1a14, 0x3400080}, +{0x3400000, 0x1, 0x77f31e2f, 0xf7f31e2f, 0x3400080}, +{0x3400000, 0x1, 0xaab4d7d8, 0x2ab4d7d8, 0x3400080}, +{0x3400000, 0x1, 0x966320b, 0x8966320b, 0x3400080}, +{0x3400000, 0x1, 0xb26bddee, 0x326bddee, 0x3400080}, +{0x3400000, 0x1, 0xb5c8e5d3, 0x35c8e5d3, 0x3400080}, +{0x3400000, 0x1, 0x317285d3, 0xb17285d3, 0x3400080}, +{0x3400000, 0x1, 0x3c9623b1, 0xbc9623b1, 0x3400080}, +{0x3400000, 0x1, 0x51fd2c7c, 0xd1fd2c7c, 0x3400080}, +{0x3400000, 0x1, 0x7b906a6c, 0xfb906a6c, 0x3400080}, +{0x3400000, 0x76, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x800000, 0x80800000, 0x3400080}, +{0x3400000, 0x76, 0x800002, 0x80800002, 0x3400080}, +{0x3400000, 0x76, 0x1398437, 0x81398437, 0x3400080}, +{0x3400000, 0x76, 0xba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x76, 0xba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x76, 0x751f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x76, 0x7f7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x76, 0x7f7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x76, 0x7f800000, 0xff800000, 0x3400080}, +{0x3400000, 0x76, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x76, 0x80800000, 0x800000, 0x3400080}, +{0x3400000, 0x76, 0x80800002, 0x800002, 0x3400080}, +{0x3400000, 0x76, 0x81398437, 0x1398437, 0x3400080}, +{0x3400000, 0x76, 0x8ba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x76, 0x8ba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x76, 0xf51f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x76, 0xff7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x76, 0xff7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x76, 0xff800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x76, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x76, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x76, 0x4f3495cb, 0xcf3495cb, 0x3400080}, +{0x3400000, 0x76, 0xe73a5134, 0x673a5134, 0x3400080}, +{0x3400000, 0x76, 0x7c994e9e, 0xfc994e9e, 0x3400080}, +{0x3400000, 0x76, 0x6164bd6c, 0xe164bd6c, 0x3400080}, +{0x3400000, 0x76, 0x9503366, 0x89503366, 0x3400080}, +{0x3400000, 0x76, 0xbf5a97c9, 0x3f5a97c9, 0x3400080}, +{0x3400000, 0x76, 0xe6ff1a14, 0x66ff1a14, 0x3400080}, +{0x3400000, 0x76, 0x77f31e2f, 0xf7f31e2f, 0x3400080}, +{0x3400000, 0x76, 0xaab4d7d8, 0x2ab4d7d8, 0x3400080}, +{0x3400000, 0x76, 0x966320b, 0x8966320b, 0x3400080}, +{0x3400000, 0x76, 0xb26bddee, 0x326bddee, 0x3400080}, +{0x3400000, 0x76, 0xb5c8e5d3, 0x35c8e5d3, 0x3400080}, +{0x3400000, 0x76, 0x317285d3, 0xb17285d3, 0x3400080}, +{0x3400000, 0x76, 0x3c9623b1, 0xbc9623b1, 0x3400080}, +{0x3400000, 0x76, 0x51fd2c7c, 0xd1fd2c7c, 0x3400080}, +{0x3400000, 0x76, 0x7b906a6c, 0xfb906a6c, 0x3400080}, +{0x3400000, 0x2b94, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x800000, 0x80800000, 0x3400080}, +{0x3400000, 0x2b94, 0x800002, 0x80800002, 0x3400080}, +{0x3400000, 0x2b94, 0x1398437, 0x81398437, 0x3400080}, +{0x3400000, 0x2b94, 0xba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x2b94, 0xba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x2b94, 0x751f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x2b94, 0x7f7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x2b94, 0x7f7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x2b94, 0x7f800000, 0xff800000, 0x3400080}, +{0x3400000, 0x2b94, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x2b94, 0x80800000, 0x800000, 0x3400080}, +{0x3400000, 0x2b94, 0x80800002, 0x800002, 0x3400080}, +{0x3400000, 0x2b94, 0x81398437, 0x1398437, 0x3400080}, +{0x3400000, 0x2b94, 0x8ba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x2b94, 0x8ba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x2b94, 0xf51f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x2b94, 0xff7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x2b94, 0xff7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x2b94, 0xff800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x2b94, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x2b94, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x2b94, 0x4f3495cb, 0xcf3495cb, 0x3400080}, +{0x3400000, 0x2b94, 0xe73a5134, 0x673a5134, 0x3400080}, +{0x3400000, 0x2b94, 0x7c994e9e, 0xfc994e9e, 0x3400080}, +{0x3400000, 0x2b94, 0x6164bd6c, 0xe164bd6c, 0x3400080}, +{0x3400000, 0x2b94, 0x9503366, 0x89503366, 0x3400080}, +{0x3400000, 0x2b94, 0xbf5a97c9, 0x3f5a97c9, 0x3400080}, +{0x3400000, 0x2b94, 0xe6ff1a14, 0x66ff1a14, 0x3400080}, +{0x3400000, 0x2b94, 0x77f31e2f, 0xf7f31e2f, 0x3400080}, +{0x3400000, 0x2b94, 0xaab4d7d8, 0x2ab4d7d8, 0x3400080}, +{0x3400000, 0x2b94, 0x966320b, 0x8966320b, 0x3400080}, +{0x3400000, 0x2b94, 0xb26bddee, 0x326bddee, 0x3400080}, +{0x3400000, 0x2b94, 0xb5c8e5d3, 0x35c8e5d3, 0x3400080}, +{0x3400000, 0x2b94, 0x317285d3, 0xb17285d3, 0x3400080}, +{0x3400000, 0x2b94, 0x3c9623b1, 0xbc9623b1, 0x3400080}, +{0x3400000, 0x2b94, 0x51fd2c7c, 0xd1fd2c7c, 0x3400080}, +{0x3400000, 0x2b94, 0x7b906a6c, 0xfb906a6c, 0x3400080}, +{0x3400000, 0x636d24, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x800000, 0x80800000, 0x3400080}, +{0x3400000, 0x636d24, 0x800002, 0x80800002, 0x3400080}, +{0x3400000, 0x636d24, 0x1398437, 0x81398437, 0x3400080}, +{0x3400000, 0x636d24, 0xba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x636d24, 0xba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x636d24, 0x751f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x636d24, 0x7f7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x636d24, 0x7f7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x636d24, 0x7f800000, 0xff800000, 0x3400080}, +{0x3400000, 0x636d24, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x636d24, 0x80800000, 0x800000, 0x3400080}, +{0x3400000, 0x636d24, 0x80800002, 0x800002, 0x3400080}, +{0x3400000, 0x636d24, 0x81398437, 0x1398437, 0x3400080}, +{0x3400000, 0x636d24, 0x8ba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x636d24, 0x8ba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x636d24, 0xf51f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x636d24, 0xff7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x636d24, 0xff7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x636d24, 0xff800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x636d24, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x636d24, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x636d24, 0x4f3495cb, 0xcf3495cb, 0x3400080}, +{0x3400000, 0x636d24, 0xe73a5134, 0x673a5134, 0x3400080}, +{0x3400000, 0x636d24, 0x7c994e9e, 0xfc994e9e, 0x3400080}, +{0x3400000, 0x636d24, 0x6164bd6c, 0xe164bd6c, 0x3400080}, +{0x3400000, 0x636d24, 0x9503366, 0x89503366, 0x3400080}, +{0x3400000, 0x636d24, 0xbf5a97c9, 0x3f5a97c9, 0x3400080}, +{0x3400000, 0x636d24, 0xe6ff1a14, 0x66ff1a14, 0x3400080}, +{0x3400000, 0x636d24, 0x77f31e2f, 0xf7f31e2f, 0x3400080}, +{0x3400000, 0x636d24, 0xaab4d7d8, 0x2ab4d7d8, 0x3400080}, +{0x3400000, 0x636d24, 0x966320b, 0x8966320b, 0x3400080}, +{0x3400000, 0x636d24, 0xb26bddee, 0x326bddee, 0x3400080}, +{0x3400000, 0x636d24, 0xb5c8e5d3, 0x35c8e5d3, 0x3400080}, +{0x3400000, 0x636d24, 0x317285d3, 0xb17285d3, 0x3400080}, +{0x3400000, 0x636d24, 0x3c9623b1, 0xbc9623b1, 0x3400080}, +{0x3400000, 0x636d24, 0x51fd2c7c, 0xd1fd2c7c, 0x3400080}, +{0x3400000, 0x636d24, 0x7b906a6c, 0xfb906a6c, 0x3400080}, +{0x3400000, 0x7fffff, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x800000, 0x80800000, 0x3400080}, +{0x3400000, 0x7fffff, 0x800002, 0x80800002, 0x3400080}, +{0x3400000, 0x7fffff, 0x1398437, 0x81398437, 0x3400080}, +{0x3400000, 0x7fffff, 0xba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x7fffff, 0xba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x7fffff, 0x751f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x7fffff, 0x7f7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x7fffff, 0x7f7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x7fffff, 0x7f800000, 0xff800000, 0x3400080}, +{0x3400000, 0x7fffff, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x7fffff, 0x80800000, 0x800000, 0x3400080}, +{0x3400000, 0x7fffff, 0x80800002, 0x800002, 0x3400080}, +{0x3400000, 0x7fffff, 0x81398437, 0x1398437, 0x3400080}, +{0x3400000, 0x7fffff, 0x8ba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x7fffff, 0x8ba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x7fffff, 0xf51f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x7fffff, 0xff7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7fffff, 0xff7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7fffff, 0xff800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x7fffff, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fffff, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffff, 0x4f3495cb, 0xcf3495cb, 0x3400080}, +{0x3400000, 0x7fffff, 0xe73a5134, 0x673a5134, 0x3400080}, +{0x3400000, 0x7fffff, 0x7c994e9e, 0xfc994e9e, 0x3400080}, +{0x3400000, 0x7fffff, 0x6164bd6c, 0xe164bd6c, 0x3400080}, +{0x3400000, 0x7fffff, 0x9503366, 0x89503366, 0x3400080}, +{0x3400000, 0x7fffff, 0xbf5a97c9, 0x3f5a97c9, 0x3400080}, +{0x3400000, 0x7fffff, 0xe6ff1a14, 0x66ff1a14, 0x3400080}, +{0x3400000, 0x7fffff, 0x77f31e2f, 0xf7f31e2f, 0x3400080}, +{0x3400000, 0x7fffff, 0xaab4d7d8, 0x2ab4d7d8, 0x3400080}, +{0x3400000, 0x7fffff, 0x966320b, 0x8966320b, 0x3400080}, +{0x3400000, 0x7fffff, 0xb26bddee, 0x326bddee, 0x3400080}, +{0x3400000, 0x7fffff, 0xb5c8e5d3, 0x35c8e5d3, 0x3400080}, +{0x3400000, 0x7fffff, 0x317285d3, 0xb17285d3, 0x3400080}, +{0x3400000, 0x7fffff, 0x3c9623b1, 0xbc9623b1, 0x3400080}, +{0x3400000, 0x7fffff, 0x51fd2c7c, 0xd1fd2c7c, 0x3400080}, +{0x3400000, 0x7fffff, 0x7b906a6c, 0xfb906a6c, 0x3400080}, +{0x3400000, 0x800000, 0x0, 0x800000, 0x3400000}, +{0x3400000, 0x800000, 0x1, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x76, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x2b94, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x636d24, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x7fffff, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x800000, 0x0, 0x3400000}, +{0x3400000, 0x800000, 0x800002, 0x0, 0x3400008}, +{0x3400000, 0x800000, 0x1398437, 0x80f3086e, 0x3400000}, +{0x3400000, 0x800000, 0xba98d27, 0x8ba98d25, 0x3400000}, +{0x3400000, 0x800000, 0xba98d7a, 0x8ba98d78, 0x3400000}, +{0x3400000, 0x800000, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x800000, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x800000, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x800000, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x800000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0x80000000, 0x800000, 0x3400000}, +{0x3400000, 0x800000, 0x80000001, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x80000076, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x80002b94, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x80636d24, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x807fffff, 0x800000, 0x3400080}, +{0x3400000, 0x800000, 0x80800000, 0x1000000, 0x3400000}, +{0x3400000, 0x800000, 0x80800002, 0x1000001, 0x3400000}, +{0x3400000, 0x800000, 0x81398437, 0x1798437, 0x3400000}, +{0x3400000, 0x800000, 0x8ba98d27, 0xba98d29, 0x3400000}, +{0x3400000, 0x800000, 0x8ba98d7a, 0xba98d7c, 0x3400000}, +{0x3400000, 0x800000, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x800000, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x800000, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x800000, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x800000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800000, 0x4f3495cb, 0xcf3495ca, 0x3400010}, +{0x3400000, 0x800000, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0x800000, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0x800000, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0x800000, 0x9503366, 0x89503326, 0x3400000}, +{0x3400000, 0x800000, 0xbf5a97c9, 0x3f5a97ca, 0x3400010}, +{0x3400000, 0x800000, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0x800000, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0x800000, 0xaab4d7d8, 0x2ab4d7d9, 0x3400010}, +{0x3400000, 0x800000, 0x966320b, 0x896631cb, 0x3400000}, +{0x3400000, 0x800000, 0xb26bddee, 0x326bddef, 0x3400010}, +{0x3400000, 0x800000, 0xb5c8e5d3, 0x35c8e5d4, 0x3400010}, +{0x3400000, 0x800000, 0x317285d3, 0xb17285d2, 0x3400010}, +{0x3400000, 0x800000, 0x3c9623b1, 0xbc9623b0, 0x3400010}, +{0x3400000, 0x800000, 0x51fd2c7c, 0xd1fd2c7b, 0x3400010}, +{0x3400000, 0x800000, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0x800002, 0x0, 0x800002, 0x3400000}, +{0x3400000, 0x800002, 0x1, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x76, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x2b94, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x636d24, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x7fffff, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x800000, 0x0, 0x3400008}, +{0x3400000, 0x800002, 0x800002, 0x0, 0x3400000}, +{0x3400000, 0x800002, 0x1398437, 0x80f3086c, 0x3400000}, +{0x3400000, 0x800002, 0xba98d27, 0x8ba98d24, 0x3400010}, +{0x3400000, 0x800002, 0xba98d7a, 0x8ba98d77, 0x3400010}, +{0x3400000, 0x800002, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x800002, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x800002, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x800002, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x800002, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0x80000000, 0x800002, 0x3400000}, +{0x3400000, 0x800002, 0x80000001, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x80000076, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x80002b94, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x80636d24, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x807fffff, 0x800002, 0x3400080}, +{0x3400000, 0x800002, 0x80800000, 0x1000001, 0x3400000}, +{0x3400000, 0x800002, 0x80800002, 0x1000002, 0x3400000}, +{0x3400000, 0x800002, 0x81398437, 0x1798438, 0x3400000}, +{0x3400000, 0x800002, 0x8ba98d27, 0xba98d2a, 0x3400010}, +{0x3400000, 0x800002, 0x8ba98d7a, 0xba98d7d, 0x3400010}, +{0x3400000, 0x800002, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x800002, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x800002, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x800002, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x800002, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x800002, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x800002, 0x4f3495cb, 0xcf3495ca, 0x3400010}, +{0x3400000, 0x800002, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0x800002, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0x800002, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0x800002, 0x9503366, 0x89503325, 0x3400010}, +{0x3400000, 0x800002, 0xbf5a97c9, 0x3f5a97ca, 0x3400010}, +{0x3400000, 0x800002, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0x800002, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0x800002, 0xaab4d7d8, 0x2ab4d7d9, 0x3400010}, +{0x3400000, 0x800002, 0x966320b, 0x896631ca, 0x3400010}, +{0x3400000, 0x800002, 0xb26bddee, 0x326bddef, 0x3400010}, +{0x3400000, 0x800002, 0xb5c8e5d3, 0x35c8e5d4, 0x3400010}, +{0x3400000, 0x800002, 0x317285d3, 0xb17285d2, 0x3400010}, +{0x3400000, 0x800002, 0x3c9623b1, 0xbc9623b0, 0x3400010}, +{0x3400000, 0x800002, 0x51fd2c7c, 0xd1fd2c7b, 0x3400010}, +{0x3400000, 0x800002, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0x1398437, 0x0, 0x1398437, 0x3400000}, +{0x3400000, 0x1398437, 0x1, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x76, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x2b94, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x636d24, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x7fffff, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x800000, 0xf3086e, 0x3400000}, +{0x3400000, 0x1398437, 0x800002, 0xf3086c, 0x3400000}, +{0x3400000, 0x1398437, 0x1398437, 0x0, 0x3400000}, +{0x3400000, 0x1398437, 0xba98d27, 0x8ba98d21, 0x3400010}, +{0x3400000, 0x1398437, 0xba98d7a, 0x8ba98d74, 0x3400010}, +{0x3400000, 0x1398437, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x1398437, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x1398437, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x1398437, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x1398437, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0x80000000, 0x1398437, 0x3400000}, +{0x3400000, 0x1398437, 0x80000001, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x80000076, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x80002b94, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x80636d24, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x807fffff, 0x1398437, 0x3400080}, +{0x3400000, 0x1398437, 0x80800000, 0x1798437, 0x3400000}, +{0x3400000, 0x1398437, 0x80800002, 0x1798438, 0x3400000}, +{0x3400000, 0x1398437, 0x81398437, 0x1b98437, 0x3400000}, +{0x3400000, 0x1398437, 0x8ba98d27, 0xba98d2d, 0x3400010}, +{0x3400000, 0x1398437, 0x8ba98d7a, 0xba98d80, 0x3400010}, +{0x3400000, 0x1398437, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x1398437, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x1398437, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x1398437, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x1398437, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x1398437, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x1398437, 0x4f3495cb, 0xcf3495ca, 0x3400010}, +{0x3400000, 0x1398437, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0x1398437, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0x1398437, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0x1398437, 0x9503366, 0x895032ac, 0x3400010}, +{0x3400000, 0x1398437, 0xbf5a97c9, 0x3f5a97ca, 0x3400010}, +{0x3400000, 0x1398437, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0x1398437, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0x1398437, 0xaab4d7d8, 0x2ab4d7d9, 0x3400010}, +{0x3400000, 0x1398437, 0x966320b, 0x89663151, 0x3400010}, +{0x3400000, 0x1398437, 0xb26bddee, 0x326bddef, 0x3400010}, +{0x3400000, 0x1398437, 0xb5c8e5d3, 0x35c8e5d4, 0x3400010}, +{0x3400000, 0x1398437, 0x317285d3, 0xb17285d2, 0x3400010}, +{0x3400000, 0x1398437, 0x3c9623b1, 0xbc9623b0, 0x3400010}, +{0x3400000, 0x1398437, 0x51fd2c7c, 0xd1fd2c7b, 0x3400010}, +{0x3400000, 0x1398437, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0xba98d27, 0x0, 0xba98d27, 0x3400000}, +{0x3400000, 0xba98d27, 0x1, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x76, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x2b94, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x636d24, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x7fffff, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x800000, 0xba98d25, 0x3400000}, +{0x3400000, 0xba98d27, 0x800002, 0xba98d25, 0x3400010}, +{0x3400000, 0xba98d27, 0x1398437, 0xba98d22, 0x3400010}, +{0x3400000, 0xba98d27, 0xba98d27, 0x0, 0x3400000}, +{0x3400000, 0xba98d27, 0xba98d7a, 0x83260000, 0x3400000}, +{0x3400000, 0xba98d27, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0xba98d27, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0xba98d27, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xba98d27, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xba98d27, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0x80000000, 0xba98d27, 0x3400000}, +{0x3400000, 0xba98d27, 0x80000001, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x80000076, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x80002b94, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x80636d24, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x807fffff, 0xba98d27, 0x3400080}, +{0x3400000, 0xba98d27, 0x80800000, 0xba98d29, 0x3400000}, +{0x3400000, 0xba98d27, 0x80800002, 0xba98d2a, 0x3400010}, +{0x3400000, 0xba98d27, 0x81398437, 0xba98d2d, 0x3400010}, +{0x3400000, 0xba98d27, 0x8ba98d27, 0xc298d27, 0x3400000}, +{0x3400000, 0xba98d27, 0x8ba98d7a, 0xc298d51, 0x3400010}, +{0x3400000, 0xba98d27, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0xba98d27, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0xba98d27, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0xba98d27, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xba98d27, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d27, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d27, 0x4f3495cb, 0xcf3495ca, 0x3400010}, +{0x3400000, 0xba98d27, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0xba98d27, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0xba98d27, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0xba98d27, 0x9503366, 0xba30b8c, 0x3400010}, +{0x3400000, 0xba98d27, 0xbf5a97c9, 0x3f5a97ca, 0x3400010}, +{0x3400000, 0xba98d27, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0xba98d27, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0xba98d27, 0xaab4d7d8, 0x2ab4d7d9, 0x3400010}, +{0x3400000, 0xba98d27, 0x966320b, 0xba25b97, 0x3400010}, +{0x3400000, 0xba98d27, 0xb26bddee, 0x326bddef, 0x3400010}, +{0x3400000, 0xba98d27, 0xb5c8e5d3, 0x35c8e5d4, 0x3400010}, +{0x3400000, 0xba98d27, 0x317285d3, 0xb17285d2, 0x3400010}, +{0x3400000, 0xba98d27, 0x3c9623b1, 0xbc9623b0, 0x3400010}, +{0x3400000, 0xba98d27, 0x51fd2c7c, 0xd1fd2c7b, 0x3400010}, +{0x3400000, 0xba98d27, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0xba98d7a, 0x0, 0xba98d7a, 0x3400000}, +{0x3400000, 0xba98d7a, 0x1, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x76, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x2b94, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x636d24, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x7fffff, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x800000, 0xba98d78, 0x3400000}, +{0x3400000, 0xba98d7a, 0x800002, 0xba98d78, 0x3400010}, +{0x3400000, 0xba98d7a, 0x1398437, 0xba98d75, 0x3400010}, +{0x3400000, 0xba98d7a, 0xba98d27, 0x3260000, 0x3400000}, +{0x3400000, 0xba98d7a, 0xba98d7a, 0x0, 0x3400000}, +{0x3400000, 0xba98d7a, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0xba98d7a, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0xba98d7a, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xba98d7a, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x80000000, 0xba98d7a, 0x3400000}, +{0x3400000, 0xba98d7a, 0x80000001, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x80000076, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x80002b94, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x80636d24, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x807fffff, 0xba98d7a, 0x3400080}, +{0x3400000, 0xba98d7a, 0x80800000, 0xba98d7c, 0x3400000}, +{0x3400000, 0xba98d7a, 0x80800002, 0xba98d7d, 0x3400010}, +{0x3400000, 0xba98d7a, 0x81398437, 0xba98d80, 0x3400010}, +{0x3400000, 0xba98d7a, 0x8ba98d27, 0xc298d51, 0x3400010}, +{0x3400000, 0xba98d7a, 0x8ba98d7a, 0xc298d7a, 0x3400000}, +{0x3400000, 0xba98d7a, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0xba98d7a, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0xba98d7a, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0xba98d7a, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xba98d7a, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xba98d7a, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xba98d7a, 0x4f3495cb, 0xcf3495ca, 0x3400010}, +{0x3400000, 0xba98d7a, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0xba98d7a, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0xba98d7a, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0xba98d7a, 0x9503366, 0xba30bdf, 0x3400010}, +{0x3400000, 0xba98d7a, 0xbf5a97c9, 0x3f5a97ca, 0x3400010}, +{0x3400000, 0xba98d7a, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0xba98d7a, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0xba98d7a, 0xaab4d7d8, 0x2ab4d7d9, 0x3400010}, +{0x3400000, 0xba98d7a, 0x966320b, 0xba25bea, 0x3400010}, +{0x3400000, 0xba98d7a, 0xb26bddee, 0x326bddef, 0x3400010}, +{0x3400000, 0xba98d7a, 0xb5c8e5d3, 0x35c8e5d4, 0x3400010}, +{0x3400000, 0xba98d7a, 0x317285d3, 0xb17285d2, 0x3400010}, +{0x3400000, 0xba98d7a, 0x3c9623b1, 0xbc9623b0, 0x3400010}, +{0x3400000, 0xba98d7a, 0x51fd2c7c, 0xd1fd2c7b, 0x3400010}, +{0x3400000, 0xba98d7a, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0x751f853a, 0x0, 0x751f853a, 0x3400000}, +{0x3400000, 0x751f853a, 0x1, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x76, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x2b94, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x636d24, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x7fffff, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x800000, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x800002, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x1398437, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0xba98d27, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0xba98d7a, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x751f853a, 0x0, 0x3400000}, +{0x3400000, 0x751f853a, 0x7f7ffff0, 0xff7fffe6, 0x3400010}, +{0x3400000, 0x751f853a, 0x7f7fffff, 0xff7ffff5, 0x3400010}, +{0x3400000, 0x751f853a, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x751f853a, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0x80000000, 0x751f853a, 0x3400000}, +{0x3400000, 0x751f853a, 0x80000001, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x80000076, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x80002b94, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x80636d24, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x807fffff, 0x751f853a, 0x3400080}, +{0x3400000, 0x751f853a, 0x80800000, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x80800002, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x81398437, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x8ba98d27, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x8ba98d7a, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0xf51f853a, 0x759f853a, 0x3400000}, +{0x3400000, 0x751f853a, 0xff7ffff0, 0x7f7ffffa, 0x3400010}, +{0x3400000, 0x751f853a, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x751f853a, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x751f853a, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x751f853a, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x751f853a, 0x4f3495cb, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0xe73a5134, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x7c994e9e, 0xfc994d5e, 0x3400010}, +{0x3400000, 0x751f853a, 0x6164bd6c, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x9503366, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0xbf5a97c9, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0xe6ff1a14, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x77f31e2f, 0xf7ee2205, 0x3400010}, +{0x3400000, 0x751f853a, 0xaab4d7d8, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x966320b, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0xb26bddee, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0xb5c8e5d3, 0x751f853b, 0x3400010}, +{0x3400000, 0x751f853a, 0x317285d3, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x3c9623b1, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x51fd2c7c, 0x751f853a, 0x3400010}, +{0x3400000, 0x751f853a, 0x7b906a6c, 0xfb90656f, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x0, 0x7f7ffff0, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x1, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x76, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x2b94, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x636d24, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x7fffff, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x800000, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x800002, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x1398437, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xba98d27, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xba98d7a, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x751f853a, 0x7f7fffe7, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x7f7ffff0, 0x0, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x7f7fffff, 0xf5700000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x80000000, 0x7f7ffff0, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x80000001, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x80000076, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x80002b94, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x80636d24, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x807fffff, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x7f7ffff0, 0x80800000, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x80800002, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x81398437, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x8ba98d27, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x8ba98d7a, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xf51f853a, 0x7f7ffffa, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xff7ffff0, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7ffff0, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7ffff0, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7ffff0, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7ffff0, 0x4f3495cb, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xe73a5134, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x7c994e9e, 0x7f7b357c, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x6164bd6c, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x9503366, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xbf5a97c9, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xe6ff1a14, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x77f31e2f, 0x7f7ffe0a, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xaab4d7d8, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x966320b, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xb26bddee, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0xb5c8e5d3, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x317285d3, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x3c9623b1, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x51fd2c7c, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x7f7ffff0, 0x7b906a6c, 0x7f7edf1c, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x0, 0x7f7fffff, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x1, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x76, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x2b94, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x636d24, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x800000, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x800002, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x1398437, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0xba98d27, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0xba98d7a, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x751f853a, 0x7f7ffff6, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x7f7ffff0, 0x75700000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x7f7fffff, 0x0, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x80000000, 0x7f7fffff, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x80000001, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x80000076, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x80002b94, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x80636d24, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x807fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x7f7fffff, 0x80800000, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x80800002, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x81398437, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x8ba98d27, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x8ba98d7a, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xf51f853a, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xff7ffff0, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f7fffff, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f7fffff, 0x4f3495cb, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0xe73a5134, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x7c994e9e, 0x7f7b358b, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x6164bd6c, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x9503366, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0xbf5a97c9, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xe6ff1a14, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x77f31e2f, 0x7f7ffe19, 0x3400010}, +{0x3400000, 0x7f7fffff, 0xaab4d7d8, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x966320b, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0xb26bddee, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0xb5c8e5d3, 0x7f800000, 0x3400014}, +{0x3400000, 0x7f7fffff, 0x317285d3, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x3c9623b1, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x51fd2c7c, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x7f7fffff, 0x7b906a6c, 0x7f7edf2b, 0x3400010}, +{0x3400000, 0x7f800000, 0x0, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x1, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x76, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x2b94, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x636d24, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x7fffff, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x800002, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x1398437, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xba98d27, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xba98d7a, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x751f853a, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7f7ffff0, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7f7fffff, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0x80000000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x80000001, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x80000076, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x80002b94, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x80636d24, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x807fffff, 0x7f800000, 0x3400080}, +{0x3400000, 0x7f800000, 0x80800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x80800002, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x81398437, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x8ba98d27, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x8ba98d7a, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xf51f853a, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xff7ffff0, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xff7fffff, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7f800000, 0x4f3495cb, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xe73a5134, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7c994e9e, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x6164bd6c, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x9503366, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xbf5a97c9, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xe6ff1a14, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x77f31e2f, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xaab4d7d8, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x966320b, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xb26bddee, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0xb5c8e5d3, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x317285d3, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x3c9623b1, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x51fd2c7c, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800000, 0x7b906a6c, 0x7f800000, 0x3400000}, +{0x3400000, 0x7f800001, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f800001, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f800001, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7f984a37, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7f984a37, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x7fbfffff, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fbfffff, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fc00000, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fc00000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fc00000, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fd9ba98, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fd9ba98, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fd9ba98, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x7fffffff, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7fffffff, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7fffffff, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0x0, 0x80000000, 0x3400000}, +{0x3400000, 0x80000000, 0x1, 0x80000000, 0x3400080}, +{0x3400000, 0x80000000, 0x76, 0x80000000, 0x3400080}, +{0x3400000, 0x80000000, 0x2b94, 0x80000000, 0x3400080}, +{0x3400000, 0x80000000, 0x636d24, 0x80000000, 0x3400080}, +{0x3400000, 0x80000000, 0x7fffff, 0x80000000, 0x3400080}, +{0x3400000, 0x80000000, 0x800000, 0x80800000, 0x3400000}, +{0x3400000, 0x80000000, 0x800002, 0x80800002, 0x3400000}, +{0x3400000, 0x80000000, 0x1398437, 0x81398437, 0x3400000}, +{0x3400000, 0x80000000, 0xba98d27, 0x8ba98d27, 0x3400000}, +{0x3400000, 0x80000000, 0xba98d7a, 0x8ba98d7a, 0x3400000}, +{0x3400000, 0x80000000, 0x751f853a, 0xf51f853a, 0x3400000}, +{0x3400000, 0x80000000, 0x7f7ffff0, 0xff7ffff0, 0x3400000}, +{0x3400000, 0x80000000, 0x7f7fffff, 0xff7fffff, 0x3400000}, +{0x3400000, 0x80000000, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x80000000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0x80000000, 0x0, 0x3400000}, +{0x3400000, 0x80000000, 0x80000001, 0x80000000, 0x3400080}, +{0x3400000, 0x80000000, 0x80000076, 0x80000000, 0x3400080}, +{0x3400000, 0x80000000, 0x80002b94, 0x80000000, 0x3400080}, +{0x3400000, 0x80000000, 0x80636d24, 0x80000000, 0x3400080}, +{0x3400000, 0x80000000, 0x807fffff, 0x80000000, 0x3400080}, +{0x3400000, 0x80000000, 0x80800000, 0x800000, 0x3400000}, +{0x3400000, 0x80000000, 0x80800002, 0x800002, 0x3400000}, +{0x3400000, 0x80000000, 0x81398437, 0x1398437, 0x3400000}, +{0x3400000, 0x80000000, 0x8ba98d27, 0xba98d27, 0x3400000}, +{0x3400000, 0x80000000, 0x8ba98d7a, 0xba98d7a, 0x3400000}, +{0x3400000, 0x80000000, 0xf51f853a, 0x751f853a, 0x3400000}, +{0x3400000, 0x80000000, 0xff7ffff0, 0x7f7ffff0, 0x3400000}, +{0x3400000, 0x80000000, 0xff7fffff, 0x7f7fffff, 0x3400000}, +{0x3400000, 0x80000000, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x80000000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80000000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80000000, 0x4f3495cb, 0xcf3495cb, 0x3400000}, +{0x3400000, 0x80000000, 0xe73a5134, 0x673a5134, 0x3400000}, +{0x3400000, 0x80000000, 0x7c994e9e, 0xfc994e9e, 0x3400000}, +{0x3400000, 0x80000000, 0x6164bd6c, 0xe164bd6c, 0x3400000}, +{0x3400000, 0x80000000, 0x9503366, 0x89503366, 0x3400000}, +{0x3400000, 0x80000000, 0xbf5a97c9, 0x3f5a97c9, 0x3400000}, +{0x3400000, 0x80000000, 0xe6ff1a14, 0x66ff1a14, 0x3400000}, +{0x3400000, 0x80000000, 0x77f31e2f, 0xf7f31e2f, 0x3400000}, +{0x3400000, 0x80000000, 0xaab4d7d8, 0x2ab4d7d8, 0x3400000}, +{0x3400000, 0x80000000, 0x966320b, 0x8966320b, 0x3400000}, +{0x3400000, 0x80000000, 0xb26bddee, 0x326bddee, 0x3400000}, +{0x3400000, 0x80000000, 0xb5c8e5d3, 0x35c8e5d3, 0x3400000}, +{0x3400000, 0x80000000, 0x317285d3, 0xb17285d3, 0x3400000}, +{0x3400000, 0x80000000, 0x3c9623b1, 0xbc9623b1, 0x3400000}, +{0x3400000, 0x80000000, 0x51fd2c7c, 0xd1fd2c7c, 0x3400000}, +{0x3400000, 0x80000000, 0x7b906a6c, 0xfb906a6c, 0x3400000}, +{0x3400000, 0x80000001, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x800000, 0x80800000, 0x3400080}, +{0x3400000, 0x80000001, 0x800002, 0x80800002, 0x3400080}, +{0x3400000, 0x80000001, 0x1398437, 0x81398437, 0x3400080}, +{0x3400000, 0x80000001, 0xba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x80000001, 0xba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x80000001, 0x751f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x80000001, 0x7f7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x80000001, 0x7f7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x80000001, 0x7f800000, 0xff800000, 0x3400080}, +{0x3400000, 0x80000001, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x80000001, 0x80800000, 0x800000, 0x3400080}, +{0x3400000, 0x80000001, 0x80800002, 0x800002, 0x3400080}, +{0x3400000, 0x80000001, 0x81398437, 0x1398437, 0x3400080}, +{0x3400000, 0x80000001, 0x8ba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x80000001, 0x8ba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x80000001, 0xf51f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x80000001, 0xff7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x80000001, 0xff7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x80000001, 0xff800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x80000001, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000001, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000001, 0x4f3495cb, 0xcf3495cb, 0x3400080}, +{0x3400000, 0x80000001, 0xe73a5134, 0x673a5134, 0x3400080}, +{0x3400000, 0x80000001, 0x7c994e9e, 0xfc994e9e, 0x3400080}, +{0x3400000, 0x80000001, 0x6164bd6c, 0xe164bd6c, 0x3400080}, +{0x3400000, 0x80000001, 0x9503366, 0x89503366, 0x3400080}, +{0x3400000, 0x80000001, 0xbf5a97c9, 0x3f5a97c9, 0x3400080}, +{0x3400000, 0x80000001, 0xe6ff1a14, 0x66ff1a14, 0x3400080}, +{0x3400000, 0x80000001, 0x77f31e2f, 0xf7f31e2f, 0x3400080}, +{0x3400000, 0x80000001, 0xaab4d7d8, 0x2ab4d7d8, 0x3400080}, +{0x3400000, 0x80000001, 0x966320b, 0x8966320b, 0x3400080}, +{0x3400000, 0x80000001, 0xb26bddee, 0x326bddee, 0x3400080}, +{0x3400000, 0x80000001, 0xb5c8e5d3, 0x35c8e5d3, 0x3400080}, +{0x3400000, 0x80000001, 0x317285d3, 0xb17285d3, 0x3400080}, +{0x3400000, 0x80000001, 0x3c9623b1, 0xbc9623b1, 0x3400080}, +{0x3400000, 0x80000001, 0x51fd2c7c, 0xd1fd2c7c, 0x3400080}, +{0x3400000, 0x80000001, 0x7b906a6c, 0xfb906a6c, 0x3400080}, +{0x3400000, 0x80000076, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x800000, 0x80800000, 0x3400080}, +{0x3400000, 0x80000076, 0x800002, 0x80800002, 0x3400080}, +{0x3400000, 0x80000076, 0x1398437, 0x81398437, 0x3400080}, +{0x3400000, 0x80000076, 0xba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x80000076, 0xba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x80000076, 0x751f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x80000076, 0x7f7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x80000076, 0x7f7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x80000076, 0x7f800000, 0xff800000, 0x3400080}, +{0x3400000, 0x80000076, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x80000076, 0x80800000, 0x800000, 0x3400080}, +{0x3400000, 0x80000076, 0x80800002, 0x800002, 0x3400080}, +{0x3400000, 0x80000076, 0x81398437, 0x1398437, 0x3400080}, +{0x3400000, 0x80000076, 0x8ba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x80000076, 0x8ba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x80000076, 0xf51f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x80000076, 0xff7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x80000076, 0xff7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x80000076, 0xff800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x80000076, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80000076, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80000076, 0x4f3495cb, 0xcf3495cb, 0x3400080}, +{0x3400000, 0x80000076, 0xe73a5134, 0x673a5134, 0x3400080}, +{0x3400000, 0x80000076, 0x7c994e9e, 0xfc994e9e, 0x3400080}, +{0x3400000, 0x80000076, 0x6164bd6c, 0xe164bd6c, 0x3400080}, +{0x3400000, 0x80000076, 0x9503366, 0x89503366, 0x3400080}, +{0x3400000, 0x80000076, 0xbf5a97c9, 0x3f5a97c9, 0x3400080}, +{0x3400000, 0x80000076, 0xe6ff1a14, 0x66ff1a14, 0x3400080}, +{0x3400000, 0x80000076, 0x77f31e2f, 0xf7f31e2f, 0x3400080}, +{0x3400000, 0x80000076, 0xaab4d7d8, 0x2ab4d7d8, 0x3400080}, +{0x3400000, 0x80000076, 0x966320b, 0x8966320b, 0x3400080}, +{0x3400000, 0x80000076, 0xb26bddee, 0x326bddee, 0x3400080}, +{0x3400000, 0x80000076, 0xb5c8e5d3, 0x35c8e5d3, 0x3400080}, +{0x3400000, 0x80000076, 0x317285d3, 0xb17285d3, 0x3400080}, +{0x3400000, 0x80000076, 0x3c9623b1, 0xbc9623b1, 0x3400080}, +{0x3400000, 0x80000076, 0x51fd2c7c, 0xd1fd2c7c, 0x3400080}, +{0x3400000, 0x80000076, 0x7b906a6c, 0xfb906a6c, 0x3400080}, +{0x3400000, 0x80002b94, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x800000, 0x80800000, 0x3400080}, +{0x3400000, 0x80002b94, 0x800002, 0x80800002, 0x3400080}, +{0x3400000, 0x80002b94, 0x1398437, 0x81398437, 0x3400080}, +{0x3400000, 0x80002b94, 0xba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x80002b94, 0xba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x80002b94, 0x751f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x80002b94, 0x7f7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x80002b94, 0x7f7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x80002b94, 0x7f800000, 0xff800000, 0x3400080}, +{0x3400000, 0x80002b94, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x80002b94, 0x80800000, 0x800000, 0x3400080}, +{0x3400000, 0x80002b94, 0x80800002, 0x800002, 0x3400080}, +{0x3400000, 0x80002b94, 0x81398437, 0x1398437, 0x3400080}, +{0x3400000, 0x80002b94, 0x8ba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x80002b94, 0x8ba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x80002b94, 0xf51f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x80002b94, 0xff7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x80002b94, 0xff7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x80002b94, 0xff800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x80002b94, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80002b94, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80002b94, 0x4f3495cb, 0xcf3495cb, 0x3400080}, +{0x3400000, 0x80002b94, 0xe73a5134, 0x673a5134, 0x3400080}, +{0x3400000, 0x80002b94, 0x7c994e9e, 0xfc994e9e, 0x3400080}, +{0x3400000, 0x80002b94, 0x6164bd6c, 0xe164bd6c, 0x3400080}, +{0x3400000, 0x80002b94, 0x9503366, 0x89503366, 0x3400080}, +{0x3400000, 0x80002b94, 0xbf5a97c9, 0x3f5a97c9, 0x3400080}, +{0x3400000, 0x80002b94, 0xe6ff1a14, 0x66ff1a14, 0x3400080}, +{0x3400000, 0x80002b94, 0x77f31e2f, 0xf7f31e2f, 0x3400080}, +{0x3400000, 0x80002b94, 0xaab4d7d8, 0x2ab4d7d8, 0x3400080}, +{0x3400000, 0x80002b94, 0x966320b, 0x8966320b, 0x3400080}, +{0x3400000, 0x80002b94, 0xb26bddee, 0x326bddee, 0x3400080}, +{0x3400000, 0x80002b94, 0xb5c8e5d3, 0x35c8e5d3, 0x3400080}, +{0x3400000, 0x80002b94, 0x317285d3, 0xb17285d3, 0x3400080}, +{0x3400000, 0x80002b94, 0x3c9623b1, 0xbc9623b1, 0x3400080}, +{0x3400000, 0x80002b94, 0x51fd2c7c, 0xd1fd2c7c, 0x3400080}, +{0x3400000, 0x80002b94, 0x7b906a6c, 0xfb906a6c, 0x3400080}, +{0x3400000, 0x80636d24, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x800000, 0x80800000, 0x3400080}, +{0x3400000, 0x80636d24, 0x800002, 0x80800002, 0x3400080}, +{0x3400000, 0x80636d24, 0x1398437, 0x81398437, 0x3400080}, +{0x3400000, 0x80636d24, 0xba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x80636d24, 0xba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x80636d24, 0x751f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x80636d24, 0x7f7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x80636d24, 0x7f7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x80636d24, 0x7f800000, 0xff800000, 0x3400080}, +{0x3400000, 0x80636d24, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x80636d24, 0x80800000, 0x800000, 0x3400080}, +{0x3400000, 0x80636d24, 0x80800002, 0x800002, 0x3400080}, +{0x3400000, 0x80636d24, 0x81398437, 0x1398437, 0x3400080}, +{0x3400000, 0x80636d24, 0x8ba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x80636d24, 0x8ba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x80636d24, 0xf51f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x80636d24, 0xff7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x80636d24, 0xff7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x80636d24, 0xff800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x80636d24, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x80636d24, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x80636d24, 0x4f3495cb, 0xcf3495cb, 0x3400080}, +{0x3400000, 0x80636d24, 0xe73a5134, 0x673a5134, 0x3400080}, +{0x3400000, 0x80636d24, 0x7c994e9e, 0xfc994e9e, 0x3400080}, +{0x3400000, 0x80636d24, 0x6164bd6c, 0xe164bd6c, 0x3400080}, +{0x3400000, 0x80636d24, 0x9503366, 0x89503366, 0x3400080}, +{0x3400000, 0x80636d24, 0xbf5a97c9, 0x3f5a97c9, 0x3400080}, +{0x3400000, 0x80636d24, 0xe6ff1a14, 0x66ff1a14, 0x3400080}, +{0x3400000, 0x80636d24, 0x77f31e2f, 0xf7f31e2f, 0x3400080}, +{0x3400000, 0x80636d24, 0xaab4d7d8, 0x2ab4d7d8, 0x3400080}, +{0x3400000, 0x80636d24, 0x966320b, 0x8966320b, 0x3400080}, +{0x3400000, 0x80636d24, 0xb26bddee, 0x326bddee, 0x3400080}, +{0x3400000, 0x80636d24, 0xb5c8e5d3, 0x35c8e5d3, 0x3400080}, +{0x3400000, 0x80636d24, 0x317285d3, 0xb17285d3, 0x3400080}, +{0x3400000, 0x80636d24, 0x3c9623b1, 0xbc9623b1, 0x3400080}, +{0x3400000, 0x80636d24, 0x51fd2c7c, 0xd1fd2c7c, 0x3400080}, +{0x3400000, 0x80636d24, 0x7b906a6c, 0xfb906a6c, 0x3400080}, +{0x3400000, 0x807fffff, 0x0, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x1, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x76, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x2b94, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x636d24, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x7fffff, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x800000, 0x80800000, 0x3400080}, +{0x3400000, 0x807fffff, 0x800002, 0x80800002, 0x3400080}, +{0x3400000, 0x807fffff, 0x1398437, 0x81398437, 0x3400080}, +{0x3400000, 0x807fffff, 0xba98d27, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x807fffff, 0xba98d7a, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x807fffff, 0x751f853a, 0xf51f853a, 0x3400080}, +{0x3400000, 0x807fffff, 0x7f7ffff0, 0xff7ffff0, 0x3400080}, +{0x3400000, 0x807fffff, 0x7f7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0x807fffff, 0x7f800000, 0xff800000, 0x3400080}, +{0x3400000, 0x807fffff, 0x7f800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0x7f984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0x7fbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0x7fc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0x7fd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0x7fffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0x80000000, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x80000001, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x80000076, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x80002b94, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x80636d24, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x807fffff, 0x0, 0x3400080}, +{0x3400000, 0x807fffff, 0x80800000, 0x800000, 0x3400080}, +{0x3400000, 0x807fffff, 0x80800002, 0x800002, 0x3400080}, +{0x3400000, 0x807fffff, 0x81398437, 0x1398437, 0x3400080}, +{0x3400000, 0x807fffff, 0x8ba98d27, 0xba98d27, 0x3400080}, +{0x3400000, 0x807fffff, 0x8ba98d7a, 0xba98d7a, 0x3400080}, +{0x3400000, 0x807fffff, 0xf51f853a, 0x751f853a, 0x3400080}, +{0x3400000, 0x807fffff, 0xff7ffff0, 0x7f7ffff0, 0x3400080}, +{0x3400000, 0x807fffff, 0xff7fffff, 0x7f7fffff, 0x3400080}, +{0x3400000, 0x807fffff, 0xff800000, 0x7f800000, 0x3400080}, +{0x3400000, 0x807fffff, 0xff800001, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0xff984a37, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0xffbfffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0x807fffff, 0xffc00000, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0xffd9ba98, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0xffffffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0x807fffff, 0x4f3495cb, 0xcf3495cb, 0x3400080}, +{0x3400000, 0x807fffff, 0xe73a5134, 0x673a5134, 0x3400080}, +{0x3400000, 0x807fffff, 0x7c994e9e, 0xfc994e9e, 0x3400080}, +{0x3400000, 0x807fffff, 0x6164bd6c, 0xe164bd6c, 0x3400080}, +{0x3400000, 0x807fffff, 0x9503366, 0x89503366, 0x3400080}, +{0x3400000, 0x807fffff, 0xbf5a97c9, 0x3f5a97c9, 0x3400080}, +{0x3400000, 0x807fffff, 0xe6ff1a14, 0x66ff1a14, 0x3400080}, +{0x3400000, 0x807fffff, 0x77f31e2f, 0xf7f31e2f, 0x3400080}, +{0x3400000, 0x807fffff, 0xaab4d7d8, 0x2ab4d7d8, 0x3400080}, +{0x3400000, 0x807fffff, 0x966320b, 0x8966320b, 0x3400080}, +{0x3400000, 0x807fffff, 0xb26bddee, 0x326bddee, 0x3400080}, +{0x3400000, 0x807fffff, 0xb5c8e5d3, 0x35c8e5d3, 0x3400080}, +{0x3400000, 0x807fffff, 0x317285d3, 0xb17285d3, 0x3400080}, +{0x3400000, 0x807fffff, 0x3c9623b1, 0xbc9623b1, 0x3400080}, +{0x3400000, 0x807fffff, 0x51fd2c7c, 0xd1fd2c7c, 0x3400080}, +{0x3400000, 0x807fffff, 0x7b906a6c, 0xfb906a6c, 0x3400080}, +{0x3400000, 0x80800000, 0x0, 0x80800000, 0x3400000}, +{0x3400000, 0x80800000, 0x1, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x76, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x2b94, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x636d24, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x7fffff, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x800000, 0x81000000, 0x3400000}, +{0x3400000, 0x80800000, 0x800002, 0x81000001, 0x3400000}, +{0x3400000, 0x80800000, 0x1398437, 0x81798437, 0x3400000}, +{0x3400000, 0x80800000, 0xba98d27, 0x8ba98d29, 0x3400000}, +{0x3400000, 0x80800000, 0xba98d7a, 0x8ba98d7c, 0x3400000}, +{0x3400000, 0x80800000, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0x80800000, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0x80800000, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0x80800000, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x80800000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0x80000000, 0x80800000, 0x3400000}, +{0x3400000, 0x80800000, 0x80000001, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x80000076, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x80002b94, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x80636d24, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x807fffff, 0x80800000, 0x3400080}, +{0x3400000, 0x80800000, 0x80800000, 0x0, 0x3400000}, +{0x3400000, 0x80800000, 0x80800002, 0x0, 0x3400008}, +{0x3400000, 0x80800000, 0x81398437, 0xf3086e, 0x3400000}, +{0x3400000, 0x80800000, 0x8ba98d27, 0xba98d25, 0x3400000}, +{0x3400000, 0x80800000, 0x8ba98d7a, 0xba98d78, 0x3400000}, +{0x3400000, 0x80800000, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0x80800000, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x80800000, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x80800000, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x80800000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800000, 0x4f3495cb, 0xcf3495cb, 0x3400010}, +{0x3400000, 0x80800000, 0xe73a5134, 0x673a5134, 0x3400010}, +{0x3400000, 0x80800000, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0x80800000, 0x6164bd6c, 0xe164bd6c, 0x3400010}, +{0x3400000, 0x80800000, 0x9503366, 0x895033a6, 0x3400000}, +{0x3400000, 0x80800000, 0xbf5a97c9, 0x3f5a97c9, 0x3400010}, +{0x3400000, 0x80800000, 0xe6ff1a14, 0x66ff1a14, 0x3400010}, +{0x3400000, 0x80800000, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0x80800000, 0xaab4d7d8, 0x2ab4d7d8, 0x3400010}, +{0x3400000, 0x80800000, 0x966320b, 0x8966324b, 0x3400000}, +{0x3400000, 0x80800000, 0xb26bddee, 0x326bddee, 0x3400010}, +{0x3400000, 0x80800000, 0xb5c8e5d3, 0x35c8e5d3, 0x3400010}, +{0x3400000, 0x80800000, 0x317285d3, 0xb17285d3, 0x3400010}, +{0x3400000, 0x80800000, 0x3c9623b1, 0xbc9623b1, 0x3400010}, +{0x3400000, 0x80800000, 0x51fd2c7c, 0xd1fd2c7c, 0x3400010}, +{0x3400000, 0x80800000, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0x80800002, 0x0, 0x80800002, 0x3400000}, +{0x3400000, 0x80800002, 0x1, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x76, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x2b94, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x636d24, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x7fffff, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x800000, 0x81000001, 0x3400000}, +{0x3400000, 0x80800002, 0x800002, 0x81000002, 0x3400000}, +{0x3400000, 0x80800002, 0x1398437, 0x81798438, 0x3400000}, +{0x3400000, 0x80800002, 0xba98d27, 0x8ba98d29, 0x3400010}, +{0x3400000, 0x80800002, 0xba98d7a, 0x8ba98d7c, 0x3400010}, +{0x3400000, 0x80800002, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0x80800002, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0x80800002, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0x80800002, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x80800002, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0x80000000, 0x80800002, 0x3400000}, +{0x3400000, 0x80800002, 0x80000001, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x80000076, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x80002b94, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x80636d24, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x807fffff, 0x80800002, 0x3400080}, +{0x3400000, 0x80800002, 0x80800000, 0x0, 0x3400008}, +{0x3400000, 0x80800002, 0x80800002, 0x0, 0x3400000}, +{0x3400000, 0x80800002, 0x81398437, 0xf3086c, 0x3400000}, +{0x3400000, 0x80800002, 0x8ba98d27, 0xba98d25, 0x3400010}, +{0x3400000, 0x80800002, 0x8ba98d7a, 0xba98d78, 0x3400010}, +{0x3400000, 0x80800002, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0x80800002, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x80800002, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x80800002, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x80800002, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x80800002, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x80800002, 0x4f3495cb, 0xcf3495cb, 0x3400010}, +{0x3400000, 0x80800002, 0xe73a5134, 0x673a5134, 0x3400010}, +{0x3400000, 0x80800002, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0x80800002, 0x6164bd6c, 0xe164bd6c, 0x3400010}, +{0x3400000, 0x80800002, 0x9503366, 0x895033a6, 0x3400010}, +{0x3400000, 0x80800002, 0xbf5a97c9, 0x3f5a97c9, 0x3400010}, +{0x3400000, 0x80800002, 0xe6ff1a14, 0x66ff1a14, 0x3400010}, +{0x3400000, 0x80800002, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0x80800002, 0xaab4d7d8, 0x2ab4d7d8, 0x3400010}, +{0x3400000, 0x80800002, 0x966320b, 0x8966324b, 0x3400010}, +{0x3400000, 0x80800002, 0xb26bddee, 0x326bddee, 0x3400010}, +{0x3400000, 0x80800002, 0xb5c8e5d3, 0x35c8e5d3, 0x3400010}, +{0x3400000, 0x80800002, 0x317285d3, 0xb17285d3, 0x3400010}, +{0x3400000, 0x80800002, 0x3c9623b1, 0xbc9623b1, 0x3400010}, +{0x3400000, 0x80800002, 0x51fd2c7c, 0xd1fd2c7c, 0x3400010}, +{0x3400000, 0x80800002, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0x81398437, 0x0, 0x81398437, 0x3400000}, +{0x3400000, 0x81398437, 0x1, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x76, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x2b94, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x636d24, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x7fffff, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x800000, 0x81798437, 0x3400000}, +{0x3400000, 0x81398437, 0x800002, 0x81798438, 0x3400000}, +{0x3400000, 0x81398437, 0x1398437, 0x81b98437, 0x3400000}, +{0x3400000, 0x81398437, 0xba98d27, 0x8ba98d2c, 0x3400010}, +{0x3400000, 0x81398437, 0xba98d7a, 0x8ba98d7f, 0x3400010}, +{0x3400000, 0x81398437, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0x81398437, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0x81398437, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0x81398437, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x81398437, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0x80000000, 0x81398437, 0x3400000}, +{0x3400000, 0x81398437, 0x80000001, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x80000076, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x80002b94, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x80636d24, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x807fffff, 0x81398437, 0x3400080}, +{0x3400000, 0x81398437, 0x80800000, 0x80f3086e, 0x3400000}, +{0x3400000, 0x81398437, 0x80800002, 0x80f3086c, 0x3400000}, +{0x3400000, 0x81398437, 0x81398437, 0x0, 0x3400000}, +{0x3400000, 0x81398437, 0x8ba98d27, 0xba98d22, 0x3400010}, +{0x3400000, 0x81398437, 0x8ba98d7a, 0xba98d75, 0x3400010}, +{0x3400000, 0x81398437, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0x81398437, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x81398437, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x81398437, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x81398437, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x81398437, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x81398437, 0x4f3495cb, 0xcf3495cb, 0x3400010}, +{0x3400000, 0x81398437, 0xe73a5134, 0x673a5134, 0x3400010}, +{0x3400000, 0x81398437, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0x81398437, 0x6164bd6c, 0xe164bd6c, 0x3400010}, +{0x3400000, 0x81398437, 0x9503366, 0x8950341f, 0x3400010}, +{0x3400000, 0x81398437, 0xbf5a97c9, 0x3f5a97c9, 0x3400010}, +{0x3400000, 0x81398437, 0xe6ff1a14, 0x66ff1a14, 0x3400010}, +{0x3400000, 0x81398437, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0x81398437, 0xaab4d7d8, 0x2ab4d7d8, 0x3400010}, +{0x3400000, 0x81398437, 0x966320b, 0x896632c4, 0x3400010}, +{0x3400000, 0x81398437, 0xb26bddee, 0x326bddee, 0x3400010}, +{0x3400000, 0x81398437, 0xb5c8e5d3, 0x35c8e5d3, 0x3400010}, +{0x3400000, 0x81398437, 0x317285d3, 0xb17285d3, 0x3400010}, +{0x3400000, 0x81398437, 0x3c9623b1, 0xbc9623b1, 0x3400010}, +{0x3400000, 0x81398437, 0x51fd2c7c, 0xd1fd2c7c, 0x3400010}, +{0x3400000, 0x81398437, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x0, 0x8ba98d27, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x1, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x76, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x2b94, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x636d24, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x7fffff, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x800000, 0x8ba98d29, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x800002, 0x8ba98d29, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x1398437, 0x8ba98d2c, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xba98d27, 0x8c298d27, 0x3400000}, +{0x3400000, 0x8ba98d27, 0xba98d7a, 0x8c298d50, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x80000000, 0x8ba98d27, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x80000001, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x80000076, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x80002b94, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x80636d24, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x807fffff, 0x8ba98d27, 0x3400080}, +{0x3400000, 0x8ba98d27, 0x80800000, 0x8ba98d25, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x80800002, 0x8ba98d24, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x81398437, 0x8ba98d21, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x8ba98d27, 0x0, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x8ba98d7a, 0x3260000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d27, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d27, 0x4f3495cb, 0xcf3495cb, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xe73a5134, 0x673a5134, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x6164bd6c, 0xe164bd6c, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x9503366, 0x8bb00ec2, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xbf5a97c9, 0x3f5a97c9, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xe6ff1a14, 0x66ff1a14, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xaab4d7d8, 0x2ab4d7d8, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x966320b, 0x8bb0beb7, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xb26bddee, 0x326bddee, 0x3400010}, +{0x3400000, 0x8ba98d27, 0xb5c8e5d3, 0x35c8e5d3, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x317285d3, 0xb17285d3, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x3c9623b1, 0xbc9623b1, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x51fd2c7c, 0xd1fd2c7c, 0x3400010}, +{0x3400000, 0x8ba98d27, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x0, 0x8ba98d7a, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x1, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x76, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x2b94, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x636d24, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x7fffff, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x800000, 0x8ba98d7c, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x800002, 0x8ba98d7c, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x1398437, 0x8ba98d7f, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xba98d27, 0x8c298d50, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xba98d7a, 0x8c298d7a, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x80000000, 0x8ba98d7a, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x80000001, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x80000076, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x80002b94, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x80636d24, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x807fffff, 0x8ba98d7a, 0x3400080}, +{0x3400000, 0x8ba98d7a, 0x80800000, 0x8ba98d78, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x80800002, 0x8ba98d77, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x81398437, 0x8ba98d74, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x8ba98d27, 0x83260000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x8ba98d7a, 0x0, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x8ba98d7a, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x8ba98d7a, 0x4f3495cb, 0xcf3495cb, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xe73a5134, 0x673a5134, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x6164bd6c, 0xe164bd6c, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x9503366, 0x8bb00f15, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xbf5a97c9, 0x3f5a97c9, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xe6ff1a14, 0x66ff1a14, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xaab4d7d8, 0x2ab4d7d8, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x966320b, 0x8bb0bf0a, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xb26bddee, 0x326bddee, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0xb5c8e5d3, 0x35c8e5d3, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x317285d3, 0xb17285d3, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x3c9623b1, 0xbc9623b1, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x51fd2c7c, 0xd1fd2c7c, 0x3400010}, +{0x3400000, 0x8ba98d7a, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0xf51f853a, 0x0, 0xf51f853a, 0x3400000}, +{0x3400000, 0xf51f853a, 0x1, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x76, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x2b94, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x636d24, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x7fffff, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x800000, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x800002, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x1398437, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0xba98d27, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0xba98d7a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x751f853a, 0xf59f853a, 0x3400000}, +{0x3400000, 0xf51f853a, 0x7f7ffff0, 0xff7ffff9, 0x3400010}, +{0x3400000, 0xf51f853a, 0x7f7fffff, 0xff7fffff, 0x3400014}, +{0x3400000, 0xf51f853a, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xf51f853a, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0x80000000, 0xf51f853a, 0x3400000}, +{0x3400000, 0xf51f853a, 0x80000001, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x80000076, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x80002b94, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x80636d24, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x807fffff, 0xf51f853a, 0x3400080}, +{0x3400000, 0xf51f853a, 0x80800000, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x80800002, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x81398437, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x8ba98d27, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x8ba98d7a, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0xf51f853a, 0x0, 0x3400000}, +{0x3400000, 0xf51f853a, 0xff7ffff0, 0x7f7fffe7, 0x3400010}, +{0x3400000, 0xf51f853a, 0xff7fffff, 0x7f7ffff6, 0x3400010}, +{0x3400000, 0xf51f853a, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xf51f853a, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xf51f853a, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xf51f853a, 0x4f3495cb, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0xe73a5134, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x7c994e9e, 0xfc994fdd, 0x3400010}, +{0x3400000, 0xf51f853a, 0x6164bd6c, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x9503366, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0xbf5a97c9, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0xe6ff1a14, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x77f31e2f, 0xf7f81a58, 0x3400010}, +{0x3400000, 0xf51f853a, 0xaab4d7d8, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x966320b, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0xb26bddee, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0xb5c8e5d3, 0xf51f8539, 0x3400010}, +{0x3400000, 0xf51f853a, 0x317285d3, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x3c9623b1, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x51fd2c7c, 0xf51f853a, 0x3400010}, +{0x3400000, 0xf51f853a, 0x7b906a6c, 0xfb906f68, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x0, 0xff7ffff0, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x1, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x76, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x2b94, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x636d24, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x7fffff, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x800000, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x800002, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x1398437, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xba98d27, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xba98d7a, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x751f853a, 0xff7ffff9, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x7f7ffff0, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7ffff0, 0x7f7fffff, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7ffff0, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x80000000, 0xff7ffff0, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x80000001, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x80000076, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x80002b94, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x80636d24, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x807fffff, 0xff7ffff0, 0x3400080}, +{0x3400000, 0xff7ffff0, 0x80800000, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x80800002, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x81398437, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x8ba98d27, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x8ba98d7a, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xf51f853a, 0xff7fffe6, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xff7ffff0, 0x0, 0x3400000}, +{0x3400000, 0xff7ffff0, 0xff7fffff, 0x75700000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7ffff0, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7ffff0, 0x4f3495cb, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xe73a5134, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x7c994e9e, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7ffff0, 0x6164bd6c, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x9503366, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xbf5a97c9, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xe6ff1a14, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x77f31e2f, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7ffff0, 0xaab4d7d8, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x966320b, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xb26bddee, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0xb5c8e5d3, 0xff7fffef, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x317285d3, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x3c9623b1, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x51fd2c7c, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xff7ffff0, 0x7b906a6c, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7fffff, 0x0, 0xff7fffff, 0x3400000}, +{0x3400000, 0xff7fffff, 0x1, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x76, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x2b94, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x636d24, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x7fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x800000, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x800002, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x1398437, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0xba98d27, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0xba98d7a, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x751f853a, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7fffff, 0x7f7ffff0, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7fffff, 0x7f7fffff, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7fffff, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x80000000, 0xff7fffff, 0x3400000}, +{0x3400000, 0xff7fffff, 0x80000001, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x80000076, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x80002b94, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x80636d24, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x807fffff, 0xff7fffff, 0x3400080}, +{0x3400000, 0xff7fffff, 0x80800000, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x80800002, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x81398437, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x8ba98d27, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x8ba98d7a, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0xf51f853a, 0xff7ffff5, 0x3400010}, +{0x3400000, 0xff7fffff, 0xff7ffff0, 0xf5700000, 0x3400000}, +{0x3400000, 0xff7fffff, 0xff7fffff, 0x0, 0x3400000}, +{0x3400000, 0xff7fffff, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xff7fffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff7fffff, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff7fffff, 0x4f3495cb, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0xe73a5134, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x7c994e9e, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7fffff, 0x6164bd6c, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x9503366, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0xbf5a97c9, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0xe6ff1a14, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x77f31e2f, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff7fffff, 0xaab4d7d8, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x966320b, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0xb26bddee, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0xb5c8e5d3, 0xff7ffffe, 0x3400010}, +{0x3400000, 0xff7fffff, 0x317285d3, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x3c9623b1, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x51fd2c7c, 0xff7fffff, 0x3400010}, +{0x3400000, 0xff7fffff, 0x7b906a6c, 0xff7fffff, 0x3400014}, +{0x3400000, 0xff800000, 0x0, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x1, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x76, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x2b94, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x636d24, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x7fffff, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x800000, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x800002, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x1398437, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xba98d27, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xba98d7a, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x751f853a, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7f7ffff0, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7f7fffff, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0x80000000, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x80000001, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x80000076, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x80002b94, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x80636d24, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x807fffff, 0xff800000, 0x3400080}, +{0x3400000, 0xff800000, 0x80800000, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x80800002, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x81398437, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x8ba98d27, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x8ba98d7a, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xf51f853a, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xff7ffff0, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xff7fffff, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xff800000, 0x4f3495cb, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xe73a5134, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7c994e9e, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x6164bd6c, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x9503366, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xbf5a97c9, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xe6ff1a14, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x77f31e2f, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xaab4d7d8, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x966320b, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xb26bddee, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0xb5c8e5d3, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x317285d3, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x3c9623b1, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x51fd2c7c, 0xff800000, 0x3400000}, +{0x3400000, 0xff800000, 0x7b906a6c, 0xff800000, 0x3400000}, +{0x3400000, 0xff800001, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff800001, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff800001, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xff984a37, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xff984a37, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x1, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x76, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x2b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x7fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x1398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x751f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7f7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7f7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7f800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7fc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7fd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7fffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x80000000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x80000001, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x80000076, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x80002b94, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x80636d24, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x807fffff, 0x7fc00000, 0x3400081}, +{0x3400000, 0xffbfffff, 0x80800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x80800002, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x81398437, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x8ba98d27, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x8ba98d7a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xf51f853a, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xff7ffff0, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xff7fffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xff800000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xffc00000, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xffd9ba98, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xffffffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x4f3495cb, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xe73a5134, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7c994e9e, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x6164bd6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x9503366, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xbf5a97c9, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xe6ff1a14, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x77f31e2f, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xaab4d7d8, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x966320b, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xb26bddee, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x317285d3, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x3c9623b1, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x51fd2c7c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffbfffff, 0x7b906a6c, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffc00000, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffc00000, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffc00000, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffd9ba98, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffd9ba98, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffd9ba98, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x1, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x76, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x2b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x7fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x1398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x751f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7f7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7f7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7f800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x80000000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x80000001, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x80000076, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x80002b94, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x80636d24, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x807fffff, 0x7fc00000, 0x3400080}, +{0x3400000, 0xffffffff, 0x80800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x80800002, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x81398437, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x8ba98d27, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x8ba98d7a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xf51f853a, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xff7ffff0, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xff7fffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xff800000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xffffffff, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x4f3495cb, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xe73a5134, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7c994e9e, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x6164bd6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x9503366, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xbf5a97c9, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xe6ff1a14, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x77f31e2f, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xaab4d7d8, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x966320b, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xb26bddee, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0xb5c8e5d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x317285d3, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x3c9623b1, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x51fd2c7c, 0x7fc00000, 0x3400000}, +{0x3400000, 0xffffffff, 0x7b906a6c, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x0, 0x4f3495cb, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x1, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x76, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x2b94, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x636d24, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x7fffff, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x800000, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x800002, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x1398437, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xba98d27, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xba98d7a, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x80000000, 0x4f3495cb, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x80000001, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x80000076, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x80002b94, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x80636d24, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x807fffff, 0x4f3495cb, 0x3400080}, +{0x3400000, 0x4f3495cb, 0x80800000, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x80800002, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x81398437, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x8ba98d27, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x8ba98d7a, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x4f3495cb, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x4f3495cb, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x4f3495cb, 0x4f3495cb, 0x0, 0x3400000}, +{0x3400000, 0x4f3495cb, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x9503366, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xbf5a97c9, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xaab4d7d8, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x966320b, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xb26bddee, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0xb5c8e5d3, 0x4f3495cc, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x317285d3, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x3c9623b1, 0x4f3495cb, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x51fd2c7c, 0xd1f787cd, 0x3400010}, +{0x3400000, 0x4f3495cb, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0xe73a5134, 0x0, 0xe73a5134, 0x3400000}, +{0x3400000, 0xe73a5134, 0x1, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x76, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x2b94, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x636d24, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x7fffff, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x800000, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x800002, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x1398437, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0xba98d27, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0xba98d7a, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xe73a5134, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xe73a5134, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xe73a5134, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xe73a5134, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0x80000000, 0xe73a5134, 0x3400000}, +{0x3400000, 0xe73a5134, 0x80000001, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x80000076, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x80002b94, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x80636d24, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x807fffff, 0xe73a5134, 0x3400080}, +{0x3400000, 0xe73a5134, 0x80800000, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x80800002, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x81398437, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x8ba98d27, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x8ba98d7a, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xe73a5134, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xe73a5134, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xe73a5134, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xe73a5134, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe73a5134, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe73a5134, 0x4f3495cb, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0xe73a5134, 0x0, 0x3400000}, +{0x3400000, 0xe73a5134, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0xe73a5134, 0x6164bd6c, 0xe73a5f7f, 0x3400010}, +{0x3400000, 0xe73a5134, 0x9503366, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0xbf5a97c9, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0xe6ff1a14, 0xe66b10a8, 0x3400000}, +{0x3400000, 0xe73a5134, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0xe73a5134, 0xaab4d7d8, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x966320b, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0xb26bddee, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0xb5c8e5d3, 0xe73a5133, 0x3400010}, +{0x3400000, 0xe73a5134, 0x317285d3, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x3c9623b1, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x51fd2c7c, 0xe73a5134, 0x3400010}, +{0x3400000, 0xe73a5134, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x0, 0x7c994e9e, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x1, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x76, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x2b94, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x636d24, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x7fffff, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x800000, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x800002, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x1398437, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xba98d27, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xba98d7a, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x751f853a, 0x7c994d5f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x7f7ffff0, 0xff7b357b, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x7f7fffff, 0xff7b358a, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x80000000, 0x7c994e9e, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x80000001, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x80000076, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x80002b94, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x80636d24, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x807fffff, 0x7c994e9e, 0x3400080}, +{0x3400000, 0x7c994e9e, 0x80800000, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x80800002, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x81398437, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x8ba98d27, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x8ba98d7a, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xf51f853a, 0x7c994fde, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xff7ffff0, 0x7f800000, 0x3400014}, +{0x3400000, 0x7c994e9e, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x7c994e9e, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7c994e9e, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x4f3495cb, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xe73a5134, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x7c994e9e, 0x0, 0x3400000}, +{0x3400000, 0x7c994e9e, 0x6164bd6c, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x9503366, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xbf5a97c9, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xe6ff1a14, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x77f31e2f, 0x7c9911d7, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xaab4d7d8, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x966320b, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xb26bddee, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0xb5c8e5d3, 0x7c994e9f, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x317285d3, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x3c9623b1, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x51fd2c7c, 0x7c994e9e, 0x3400010}, +{0x3400000, 0x7c994e9e, 0x7b906a6c, 0x7c6a6806, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x0, 0x6164bd6c, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x1, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x76, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x2b94, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x636d24, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x7fffff, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x800000, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x800002, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x1398437, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xba98d27, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xba98d7a, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x80000000, 0x6164bd6c, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x80000001, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x80000076, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x80002b94, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x80636d24, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x807fffff, 0x6164bd6c, 0x3400080}, +{0x3400000, 0x6164bd6c, 0x80800000, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x80800002, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x81398437, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x8ba98d27, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x8ba98d7a, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x6164bd6c, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x6164bd6c, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x4f3495cb, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xe73a5134, 0x673a5f80, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x6164bd6c, 0x0, 0x3400000}, +{0x3400000, 0x6164bd6c, 0x9503366, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xbf5a97c9, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xe6ff1a14, 0x66ff36ac, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xaab4d7d8, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x966320b, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xb26bddee, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0xb5c8e5d3, 0x6164bd6d, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x317285d3, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x3c9623b1, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x51fd2c7c, 0x6164bd6c, 0x3400010}, +{0x3400000, 0x6164bd6c, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0x9503366, 0x0, 0x9503366, 0x3400000}, +{0x3400000, 0x9503366, 0x1, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x76, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x2b94, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x636d24, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x7fffff, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x800000, 0x9503326, 0x3400000}, +{0x3400000, 0x9503366, 0x800002, 0x9503326, 0x3400010}, +{0x3400000, 0x9503366, 0x1398437, 0x95032ad, 0x3400010}, +{0x3400000, 0x9503366, 0xba98d27, 0x8ba30b8b, 0x3400010}, +{0x3400000, 0x9503366, 0xba98d7a, 0x8ba30bde, 0x3400010}, +{0x3400000, 0x9503366, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x9503366, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x9503366, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x9503366, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x9503366, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0x80000000, 0x9503366, 0x3400000}, +{0x3400000, 0x9503366, 0x80000001, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x80000076, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x80002b94, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x80636d24, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x807fffff, 0x9503366, 0x3400080}, +{0x3400000, 0x9503366, 0x80800000, 0x95033a6, 0x3400000}, +{0x3400000, 0x9503366, 0x80800002, 0x95033a7, 0x3400010}, +{0x3400000, 0x9503366, 0x81398437, 0x9503420, 0x3400010}, +{0x3400000, 0x9503366, 0x8ba98d27, 0xbb00ec3, 0x3400010}, +{0x3400000, 0x9503366, 0x8ba98d7a, 0xbb00f16, 0x3400010}, +{0x3400000, 0x9503366, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x9503366, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x9503366, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x9503366, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x9503366, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x9503366, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x9503366, 0x4f3495cb, 0xcf3495ca, 0x3400010}, +{0x3400000, 0x9503366, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0x9503366, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0x9503366, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0x9503366, 0x9503366, 0x0, 0x3400000}, +{0x3400000, 0x9503366, 0xbf5a97c9, 0x3f5a97ca, 0x3400010}, +{0x3400000, 0x9503366, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0x9503366, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0x9503366, 0xaab4d7d8, 0x2ab4d7d9, 0x3400010}, +{0x3400000, 0x9503366, 0x966320b, 0x87aff528, 0x3400000}, +{0x3400000, 0x9503366, 0xb26bddee, 0x326bddef, 0x3400010}, +{0x3400000, 0x9503366, 0xb5c8e5d3, 0x35c8e5d4, 0x3400010}, +{0x3400000, 0x9503366, 0x317285d3, 0xb17285d2, 0x3400010}, +{0x3400000, 0x9503366, 0x3c9623b1, 0xbc9623b0, 0x3400010}, +{0x3400000, 0x9503366, 0x51fd2c7c, 0xd1fd2c7b, 0x3400010}, +{0x3400000, 0x9503366, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x0, 0xbf5a97c9, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x1, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x76, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x2b94, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x636d24, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x7fffff, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x800000, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x800002, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x1398437, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xba98d27, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xba98d7a, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x80000000, 0xbf5a97c9, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x80000001, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x80000076, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x80002b94, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x80636d24, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x807fffff, 0xbf5a97c9, 0x3400080}, +{0x3400000, 0xbf5a97c9, 0x80800000, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x80800002, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x81398437, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x8ba98d27, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x8ba98d7a, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xbf5a97c9, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0x4f3495cb, 0xcf3495cb, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xe73a5134, 0x673a5134, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x6164bd6c, 0xe164bd6c, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x9503366, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xbf5a97c9, 0x0, 0x3400000}, +{0x3400000, 0xbf5a97c9, 0xe6ff1a14, 0x66ff1a14, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xaab4d7d8, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x966320b, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xb26bddee, 0xbf5a97c8, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0xb5c8e5d3, 0xbf5a97af, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x317285d3, 0xbf5a97c9, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x3c9623b1, 0xbf5f48e6, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x51fd2c7c, 0xd1fd2c7c, 0x3400010}, +{0x3400000, 0xbf5a97c9, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x0, 0xe6ff1a14, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x1, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x76, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x2b94, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x636d24, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x7fffff, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x800000, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x800002, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x1398437, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xba98d27, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xba98d7a, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x80000000, 0xe6ff1a14, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x80000001, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x80000076, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x80002b94, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x80636d24, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x807fffff, 0xe6ff1a14, 0x3400080}, +{0x3400000, 0xe6ff1a14, 0x80800000, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x80800002, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x81398437, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x8ba98d27, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x8ba98d7a, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xe6ff1a14, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x4f3495cb, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xe73a5134, 0x666b10a8, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x6164bd6c, 0xe6ff36ab, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x9503366, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xbf5a97c9, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xe6ff1a14, 0x0, 0x3400000}, +{0x3400000, 0xe6ff1a14, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xaab4d7d8, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x966320b, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xb26bddee, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0xb5c8e5d3, 0xe6ff1a13, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x317285d3, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x3c9623b1, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x51fd2c7c, 0xe6ff1a14, 0x3400010}, +{0x3400000, 0xe6ff1a14, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x0, 0x77f31e2f, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x1, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x76, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x2b94, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x636d24, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x7fffff, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x800000, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x800002, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x1398437, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xba98d27, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xba98d7a, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x751f853a, 0x77ee2206, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x7f7ffff0, 0xff7ffe09, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x7f7fffff, 0xff7ffe18, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x80000000, 0x77f31e2f, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x80000001, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x80000076, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x80002b94, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x80636d24, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x807fffff, 0x77f31e2f, 0x3400080}, +{0x3400000, 0x77f31e2f, 0x80800000, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x80800002, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x81398437, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x8ba98d27, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x8ba98d7a, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xf51f853a, 0x77f81a59, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xff7ffff0, 0x7f800000, 0x3400014}, +{0x3400000, 0x77f31e2f, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x77f31e2f, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x77f31e2f, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x77f31e2f, 0x4f3495cb, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xe73a5134, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x7c994e9e, 0xfc9911d6, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x6164bd6c, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x9503366, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xbf5a97c9, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xe6ff1a14, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x77f31e2f, 0x0, 0x3400000}, +{0x3400000, 0x77f31e2f, 0xaab4d7d8, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x966320b, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xb26bddee, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0xb5c8e5d3, 0x77f31e30, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x317285d3, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x3c9623b1, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x51fd2c7c, 0x77f31e2f, 0x3400010}, +{0x3400000, 0x77f31e2f, 0x7b906a6c, 0xfb8f774d, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x0, 0xaab4d7d8, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x1, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x76, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x2b94, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x636d24, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x7fffff, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x800000, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x800002, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x1398437, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xba98d27, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xba98d7a, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x80000000, 0xaab4d7d8, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x80000001, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x80000076, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x80002b94, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x80636d24, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x807fffff, 0xaab4d7d8, 0x3400080}, +{0x3400000, 0xaab4d7d8, 0x80800000, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x80800002, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x81398437, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x8ba98d27, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x8ba98d7a, 0xaab4d7d7, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xaab4d7d8, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x4f3495cb, 0xcf3495cb, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xe73a5134, 0x673a5134, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x6164bd6c, 0xe164bd6c, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x9503366, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xbf5a97c9, 0x3f5a97c9, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xe6ff1a14, 0x66ff1a14, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xaab4d7d8, 0x0, 0x3400000}, +{0x3400000, 0xaab4d7d8, 0x966320b, 0xaab4d7d8, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xb26bddee, 0x326bdc85, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0xb5c8e5d3, 0x35c8e5d1, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x317285d3, 0xb1728b79, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x3c9623b1, 0xbc9623b1, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x51fd2c7c, 0xd1fd2c7c, 0x3400010}, +{0x3400000, 0xaab4d7d8, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0x966320b, 0x0, 0x966320b, 0x3400000}, +{0x3400000, 0x966320b, 0x1, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x76, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x2b94, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x636d24, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x7fffff, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x800000, 0x96631cb, 0x3400000}, +{0x3400000, 0x966320b, 0x800002, 0x96631cb, 0x3400010}, +{0x3400000, 0x966320b, 0x1398437, 0x9663152, 0x3400010}, +{0x3400000, 0x966320b, 0xba98d27, 0x8ba25b96, 0x3400010}, +{0x3400000, 0x966320b, 0xba98d7a, 0x8ba25be9, 0x3400010}, +{0x3400000, 0x966320b, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x966320b, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x966320b, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x966320b, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x966320b, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0x80000000, 0x966320b, 0x3400000}, +{0x3400000, 0x966320b, 0x80000001, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x80000076, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x80002b94, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x80636d24, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x807fffff, 0x966320b, 0x3400080}, +{0x3400000, 0x966320b, 0x80800000, 0x966324b, 0x3400000}, +{0x3400000, 0x966320b, 0x80800002, 0x966324c, 0x3400010}, +{0x3400000, 0x966320b, 0x81398437, 0x96632c5, 0x3400010}, +{0x3400000, 0x966320b, 0x8ba98d27, 0xbb0beb8, 0x3400010}, +{0x3400000, 0x966320b, 0x8ba98d7a, 0xbb0bf0b, 0x3400010}, +{0x3400000, 0x966320b, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x966320b, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x966320b, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x966320b, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x966320b, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x966320b, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x966320b, 0x4f3495cb, 0xcf3495ca, 0x3400010}, +{0x3400000, 0x966320b, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0x966320b, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0x966320b, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0x966320b, 0x9503366, 0x7aff528, 0x3400000}, +{0x3400000, 0x966320b, 0xbf5a97c9, 0x3f5a97ca, 0x3400010}, +{0x3400000, 0x966320b, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0x966320b, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0x966320b, 0xaab4d7d8, 0x2ab4d7d9, 0x3400010}, +{0x3400000, 0x966320b, 0x966320b, 0x0, 0x3400000}, +{0x3400000, 0x966320b, 0xb26bddee, 0x326bddef, 0x3400010}, +{0x3400000, 0x966320b, 0xb5c8e5d3, 0x35c8e5d4, 0x3400010}, +{0x3400000, 0x966320b, 0x317285d3, 0xb17285d2, 0x3400010}, +{0x3400000, 0x966320b, 0x3c9623b1, 0xbc9623b0, 0x3400010}, +{0x3400000, 0x966320b, 0x51fd2c7c, 0xd1fd2c7b, 0x3400010}, +{0x3400000, 0x966320b, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0xb26bddee, 0x0, 0xb26bddee, 0x3400000}, +{0x3400000, 0xb26bddee, 0x1, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x76, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x2b94, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x636d24, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x7fffff, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x800000, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0x800002, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0x1398437, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0xba98d27, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0xba98d7a, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xb26bddee, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xb26bddee, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xb26bddee, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xb26bddee, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0x80000000, 0xb26bddee, 0x3400000}, +{0x3400000, 0xb26bddee, 0x80000001, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x80000076, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x80002b94, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x80636d24, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x807fffff, 0xb26bddee, 0x3400080}, +{0x3400000, 0xb26bddee, 0x80800000, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0x80800002, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0x81398437, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0x8ba98d27, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0x8ba98d7a, 0xb26bdded, 0x3400010}, +{0x3400000, 0xb26bddee, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xb26bddee, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xb26bddee, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xb26bddee, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xb26bddee, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb26bddee, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb26bddee, 0x4f3495cb, 0xcf3495cb, 0x3400010}, +{0x3400000, 0xb26bddee, 0xe73a5134, 0x673a5134, 0x3400010}, +{0x3400000, 0xb26bddee, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0xb26bddee, 0x6164bd6c, 0xe164bd6c, 0x3400010}, +{0x3400000, 0xb26bddee, 0x9503366, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0xbf5a97c9, 0x3f5a97c9, 0x3400010}, +{0x3400000, 0xb26bddee, 0xe6ff1a14, 0x66ff1a14, 0x3400010}, +{0x3400000, 0xb26bddee, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0xb26bddee, 0xaab4d7d8, 0xb26bdc84, 0x3400010}, +{0x3400000, 0xb26bddee, 0x966320b, 0xb26bddee, 0x3400010}, +{0x3400000, 0xb26bddee, 0xb26bddee, 0x0, 0x3400000}, +{0x3400000, 0xb26bddee, 0xb5c8e5d3, 0x35c70e18, 0x3400010}, +{0x3400000, 0xb26bddee, 0x317285d3, 0xb2943fb1, 0x3400010}, +{0x3400000, 0xb26bddee, 0x3c9623b1, 0xbc9623b8, 0x3400010}, +{0x3400000, 0xb26bddee, 0x51fd2c7c, 0xd1fd2c7c, 0x3400010}, +{0x3400000, 0xb26bddee, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x0, 0xb5c8e5d3, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x1, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x76, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x2b94, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x636d24, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x7fffff, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x800000, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x800002, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x1398437, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xba98d27, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xba98d7a, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x751f853a, 0xf51f853a, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x7f7ffff0, 0xff7ffff0, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x7f7fffff, 0xff7fffff, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x80000000, 0xb5c8e5d3, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x80000001, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x80000076, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x80002b94, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x80636d24, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x807fffff, 0xb5c8e5d3, 0x3400080}, +{0x3400000, 0xb5c8e5d3, 0x80800000, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x80800002, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x81398437, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x8ba98d27, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x8ba98d7a, 0xb5c8e5d2, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xf51f853a, 0x751f853a, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xff7ffff0, 0x7f7ffff0, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xff7fffff, 0x7f7fffff, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0xb5c8e5d3, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x4f3495cb, 0xcf3495cb, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xe73a5134, 0x673a5134, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x7c994e9e, 0xfc994e9e, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x6164bd6c, 0xe164bd6c, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x9503366, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xbf5a97c9, 0x3f5a97b0, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xe6ff1a14, 0x66ff1a14, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x77f31e2f, 0xf7f31e2f, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xaab4d7d8, 0xb5c8e5d0, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x966320b, 0xb5c8e5d3, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xb26bddee, 0xb5c70e17, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0xb5c8e5d3, 0x0, 0x3400000}, +{0x3400000, 0xb5c8e5d3, 0x317285d3, 0xb5c95f15, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x3c9623b1, 0xbc9626d4, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x51fd2c7c, 0xd1fd2c7c, 0x3400010}, +{0x3400000, 0xb5c8e5d3, 0x7b906a6c, 0xfb906a6c, 0x3400010}, +{0x3400000, 0x317285d3, 0x0, 0x317285d3, 0x3400000}, +{0x3400000, 0x317285d3, 0x1, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x76, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x2b94, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x636d24, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x7fffff, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x800000, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0x800002, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0x1398437, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0xba98d27, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0xba98d7a, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x317285d3, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x317285d3, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x317285d3, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x317285d3, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0x80000000, 0x317285d3, 0x3400000}, +{0x3400000, 0x317285d3, 0x80000001, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x80000076, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x80002b94, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x80636d24, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x807fffff, 0x317285d3, 0x3400080}, +{0x3400000, 0x317285d3, 0x80800000, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0x80800002, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0x81398437, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0x8ba98d27, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0x8ba98d7a, 0x317285d4, 0x3400010}, +{0x3400000, 0x317285d3, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x317285d3, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x317285d3, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x317285d3, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x317285d3, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x317285d3, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x317285d3, 0x4f3495cb, 0xcf3495ca, 0x3400010}, +{0x3400000, 0x317285d3, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0x317285d3, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0x317285d3, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0x317285d3, 0x9503366, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0xbf5a97c9, 0x3f5a97ca, 0x3400010}, +{0x3400000, 0x317285d3, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0x317285d3, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0x317285d3, 0xaab4d7d8, 0x31728b7a, 0x3400010}, +{0x3400000, 0x317285d3, 0x966320b, 0x317285d3, 0x3400010}, +{0x3400000, 0x317285d3, 0xb26bddee, 0x32943fb2, 0x3400010}, +{0x3400000, 0x317285d3, 0xb5c8e5d3, 0x35c95f16, 0x3400010}, +{0x3400000, 0x317285d3, 0x317285d3, 0x0, 0x3400000}, +{0x3400000, 0x317285d3, 0x3c9623b1, 0xbc9623af, 0x3400010}, +{0x3400000, 0x317285d3, 0x51fd2c7c, 0xd1fd2c7b, 0x3400010}, +{0x3400000, 0x317285d3, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x0, 0x3c9623b1, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x1, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x76, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x2b94, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x636d24, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x7fffff, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x800000, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x800002, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x1398437, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xba98d27, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xba98d7a, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x80000000, 0x3c9623b1, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x80000001, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x80000076, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x80002b94, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x80636d24, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x807fffff, 0x3c9623b1, 0x3400080}, +{0x3400000, 0x3c9623b1, 0x80800000, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x80800002, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x81398437, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x8ba98d27, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x8ba98d7a, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x3c9623b1, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x3c9623b1, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x4f3495cb, 0xcf3495ca, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x9503366, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xbf5a97c9, 0x3f5f48e7, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xaab4d7d8, 0x3c9623b2, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x966320b, 0x3c9623b1, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xb26bddee, 0x3c9623b9, 0x3400010}, +{0x3400000, 0x3c9623b1, 0xb5c8e5d3, 0x3c9626d5, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x317285d3, 0x3c9623b0, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x3c9623b1, 0x0, 0x3400000}, +{0x3400000, 0x3c9623b1, 0x51fd2c7c, 0xd1fd2c7b, 0x3400010}, +{0x3400000, 0x3c9623b1, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x0, 0x51fd2c7c, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x1, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x76, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x2b94, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x636d24, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x7fffff, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x800000, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x800002, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x1398437, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xba98d27, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xba98d7a, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x751f853a, 0xf51f8539, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x7f7ffff0, 0xff7fffef, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x7f7fffff, 0xff7ffffe, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x80000000, 0x51fd2c7c, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x80000001, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x80000076, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x80002b94, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x80636d24, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x807fffff, 0x51fd2c7c, 0x3400080}, +{0x3400000, 0x51fd2c7c, 0x80800000, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x80800002, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x81398437, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x8ba98d27, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x8ba98d7a, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xf51f853a, 0x751f853b, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xff7ffff0, 0x7f7ffff1, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x51fd2c7c, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x51fd2c7c, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x4f3495cb, 0x51f787ce, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xe73a5134, 0x673a5135, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x7c994e9e, 0xfc994e9d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x6164bd6c, 0xe164bd6b, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x9503366, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xbf5a97c9, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xe6ff1a14, 0x66ff1a15, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x77f31e2f, 0xf7f31e2e, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xaab4d7d8, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x966320b, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xb26bddee, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0xb5c8e5d3, 0x51fd2c7d, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x317285d3, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x3c9623b1, 0x51fd2c7c, 0x3400010}, +{0x3400000, 0x51fd2c7c, 0x51fd2c7c, 0x0, 0x3400000}, +{0x3400000, 0x51fd2c7c, 0x7b906a6c, 0xfb906a6b, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x0, 0x7b906a6c, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x1, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x76, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x2b94, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x636d24, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x7fffff, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x800000, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x800002, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x1398437, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xba98d27, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xba98d7a, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x751f853a, 0x7b906570, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x7f7ffff0, 0xff7edf1b, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x7f7fffff, 0xff7edf2a, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x7f800000, 0xff800000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x7f800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0x7f984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0x7fbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0x7fc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x7fd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x7fffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x80000000, 0x7b906a6c, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x80000001, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x80000076, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x80002b94, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x80636d24, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x807fffff, 0x7b906a6c, 0x3400080}, +{0x3400000, 0x7b906a6c, 0x80800000, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x80800002, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x81398437, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x8ba98d27, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x8ba98d7a, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xf51f853a, 0x7b906f69, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xff7ffff0, 0x7f800000, 0x3400014}, +{0x3400000, 0x7b906a6c, 0xff7fffff, 0x7f800000, 0x3400014}, +{0x3400000, 0x7b906a6c, 0xff800000, 0x7f800000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0xff800001, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0xff984a37, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0xffbfffff, 0x7fc00000, 0x3400001}, +{0x3400000, 0x7b906a6c, 0xffc00000, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0xffd9ba98, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0xffffffff, 0x7fc00000, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x4f3495cb, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xe73a5134, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x7c994e9e, 0xfc6a6806, 0x3400000}, +{0x3400000, 0x7b906a6c, 0x6164bd6c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x9503366, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xbf5a97c9, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xe6ff1a14, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x77f31e2f, 0x7b8f774e, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xaab4d7d8, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x966320b, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xb26bddee, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0xb5c8e5d3, 0x7b906a6d, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x317285d3, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x3c9623b1, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x51fd2c7c, 0x7b906a6c, 0x3400010}, +{0x3400000, 0x7b906a6c, 0x7b906a6c, 0x0, 0x3400000}, +{0x3000000, 0x0, 0x0, 0x0, 0x3000000}, +{0x3000000, 0x0, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x800000, 0x80800000, 0x3000000}, +{0x3000000, 0x0, 0x800002, 0x80800002, 0x3000000}, +{0x3000000, 0x0, 0x1398437, 0x81398437, 0x3000000}, +{0x3000000, 0x0, 0xba98d27, 0x8ba98d27, 0x3000000}, +{0x3000000, 0x0, 0xba98d7a, 0x8ba98d7a, 0x3000000}, +{0x3000000, 0x0, 0x751f853a, 0xf51f853a, 0x3000000}, +{0x3000000, 0x0, 0x7f7ffff0, 0xff7ffff0, 0x3000000}, +{0x3000000, 0x0, 0x7f7fffff, 0xff7fffff, 0x3000000}, +{0x3000000, 0x0, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x0, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0x80000000, 0x0, 0x3000000}, +{0x3000000, 0x0, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x0, 0x80800000, 0x800000, 0x3000000}, +{0x3000000, 0x0, 0x80800002, 0x800002, 0x3000000}, +{0x3000000, 0x0, 0x81398437, 0x1398437, 0x3000000}, +{0x3000000, 0x0, 0x8ba98d27, 0xba98d27, 0x3000000}, +{0x3000000, 0x0, 0x8ba98d7a, 0xba98d7a, 0x3000000}, +{0x3000000, 0x0, 0xf51f853a, 0x751f853a, 0x3000000}, +{0x3000000, 0x0, 0xff7ffff0, 0x7f7ffff0, 0x3000000}, +{0x3000000, 0x0, 0xff7fffff, 0x7f7fffff, 0x3000000}, +{0x3000000, 0x0, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x0, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x0, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x0, 0x4f3495cb, 0xcf3495cb, 0x3000000}, +{0x3000000, 0x0, 0xe73a5134, 0x673a5134, 0x3000000}, +{0x3000000, 0x0, 0x7c994e9e, 0xfc994e9e, 0x3000000}, +{0x3000000, 0x0, 0x6164bd6c, 0xe164bd6c, 0x3000000}, +{0x3000000, 0x0, 0x9503366, 0x89503366, 0x3000000}, +{0x3000000, 0x0, 0xbf5a97c9, 0x3f5a97c9, 0x3000000}, +{0x3000000, 0x0, 0xe6ff1a14, 0x66ff1a14, 0x3000000}, +{0x3000000, 0x0, 0x77f31e2f, 0xf7f31e2f, 0x3000000}, +{0x3000000, 0x0, 0xaab4d7d8, 0x2ab4d7d8, 0x3000000}, +{0x3000000, 0x0, 0x966320b, 0x8966320b, 0x3000000}, +{0x3000000, 0x0, 0xb26bddee, 0x326bddee, 0x3000000}, +{0x3000000, 0x0, 0xb5c8e5d3, 0x35c8e5d3, 0x3000000}, +{0x3000000, 0x0, 0x317285d3, 0xb17285d3, 0x3000000}, +{0x3000000, 0x0, 0x3c9623b1, 0xbc9623b1, 0x3000000}, +{0x3000000, 0x0, 0x51fd2c7c, 0xd1fd2c7c, 0x3000000}, +{0x3000000, 0x0, 0x7b906a6c, 0xfb906a6c, 0x3000000}, +{0x3000000, 0x1, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x800000, 0x80800000, 0x3000080}, +{0x3000000, 0x1, 0x800002, 0x80800002, 0x3000080}, +{0x3000000, 0x1, 0x1398437, 0x81398437, 0x3000080}, +{0x3000000, 0x1, 0xba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x1, 0xba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x1, 0x751f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x1, 0x7f7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x1, 0x7f7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x1, 0x7f800000, 0xff800000, 0x3000080}, +{0x3000000, 0x1, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x1, 0x80800000, 0x800000, 0x3000080}, +{0x3000000, 0x1, 0x80800002, 0x800002, 0x3000080}, +{0x3000000, 0x1, 0x81398437, 0x1398437, 0x3000080}, +{0x3000000, 0x1, 0x8ba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x1, 0x8ba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x1, 0xf51f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x1, 0xff7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x1, 0xff7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x1, 0xff800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x1, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x1, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x1, 0x4f3495cb, 0xcf3495cb, 0x3000080}, +{0x3000000, 0x1, 0xe73a5134, 0x673a5134, 0x3000080}, +{0x3000000, 0x1, 0x7c994e9e, 0xfc994e9e, 0x3000080}, +{0x3000000, 0x1, 0x6164bd6c, 0xe164bd6c, 0x3000080}, +{0x3000000, 0x1, 0x9503366, 0x89503366, 0x3000080}, +{0x3000000, 0x1, 0xbf5a97c9, 0x3f5a97c9, 0x3000080}, +{0x3000000, 0x1, 0xe6ff1a14, 0x66ff1a14, 0x3000080}, +{0x3000000, 0x1, 0x77f31e2f, 0xf7f31e2f, 0x3000080}, +{0x3000000, 0x1, 0xaab4d7d8, 0x2ab4d7d8, 0x3000080}, +{0x3000000, 0x1, 0x966320b, 0x8966320b, 0x3000080}, +{0x3000000, 0x1, 0xb26bddee, 0x326bddee, 0x3000080}, +{0x3000000, 0x1, 0xb5c8e5d3, 0x35c8e5d3, 0x3000080}, +{0x3000000, 0x1, 0x317285d3, 0xb17285d3, 0x3000080}, +{0x3000000, 0x1, 0x3c9623b1, 0xbc9623b1, 0x3000080}, +{0x3000000, 0x1, 0x51fd2c7c, 0xd1fd2c7c, 0x3000080}, +{0x3000000, 0x1, 0x7b906a6c, 0xfb906a6c, 0x3000080}, +{0x3000000, 0x76, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x800000, 0x80800000, 0x3000080}, +{0x3000000, 0x76, 0x800002, 0x80800002, 0x3000080}, +{0x3000000, 0x76, 0x1398437, 0x81398437, 0x3000080}, +{0x3000000, 0x76, 0xba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x76, 0xba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x76, 0x751f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x76, 0x7f7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x76, 0x7f7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x76, 0x7f800000, 0xff800000, 0x3000080}, +{0x3000000, 0x76, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x76, 0x80800000, 0x800000, 0x3000080}, +{0x3000000, 0x76, 0x80800002, 0x800002, 0x3000080}, +{0x3000000, 0x76, 0x81398437, 0x1398437, 0x3000080}, +{0x3000000, 0x76, 0x8ba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x76, 0x8ba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x76, 0xf51f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x76, 0xff7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x76, 0xff7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x76, 0xff800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x76, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x76, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x76, 0x4f3495cb, 0xcf3495cb, 0x3000080}, +{0x3000000, 0x76, 0xe73a5134, 0x673a5134, 0x3000080}, +{0x3000000, 0x76, 0x7c994e9e, 0xfc994e9e, 0x3000080}, +{0x3000000, 0x76, 0x6164bd6c, 0xe164bd6c, 0x3000080}, +{0x3000000, 0x76, 0x9503366, 0x89503366, 0x3000080}, +{0x3000000, 0x76, 0xbf5a97c9, 0x3f5a97c9, 0x3000080}, +{0x3000000, 0x76, 0xe6ff1a14, 0x66ff1a14, 0x3000080}, +{0x3000000, 0x76, 0x77f31e2f, 0xf7f31e2f, 0x3000080}, +{0x3000000, 0x76, 0xaab4d7d8, 0x2ab4d7d8, 0x3000080}, +{0x3000000, 0x76, 0x966320b, 0x8966320b, 0x3000080}, +{0x3000000, 0x76, 0xb26bddee, 0x326bddee, 0x3000080}, +{0x3000000, 0x76, 0xb5c8e5d3, 0x35c8e5d3, 0x3000080}, +{0x3000000, 0x76, 0x317285d3, 0xb17285d3, 0x3000080}, +{0x3000000, 0x76, 0x3c9623b1, 0xbc9623b1, 0x3000080}, +{0x3000000, 0x76, 0x51fd2c7c, 0xd1fd2c7c, 0x3000080}, +{0x3000000, 0x76, 0x7b906a6c, 0xfb906a6c, 0x3000080}, +{0x3000000, 0x2b94, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x800000, 0x80800000, 0x3000080}, +{0x3000000, 0x2b94, 0x800002, 0x80800002, 0x3000080}, +{0x3000000, 0x2b94, 0x1398437, 0x81398437, 0x3000080}, +{0x3000000, 0x2b94, 0xba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x2b94, 0xba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x2b94, 0x751f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x2b94, 0x7f7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x2b94, 0x7f7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x2b94, 0x7f800000, 0xff800000, 0x3000080}, +{0x3000000, 0x2b94, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x2b94, 0x80800000, 0x800000, 0x3000080}, +{0x3000000, 0x2b94, 0x80800002, 0x800002, 0x3000080}, +{0x3000000, 0x2b94, 0x81398437, 0x1398437, 0x3000080}, +{0x3000000, 0x2b94, 0x8ba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x2b94, 0x8ba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x2b94, 0xf51f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x2b94, 0xff7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x2b94, 0xff7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x2b94, 0xff800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x2b94, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x2b94, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x2b94, 0x4f3495cb, 0xcf3495cb, 0x3000080}, +{0x3000000, 0x2b94, 0xe73a5134, 0x673a5134, 0x3000080}, +{0x3000000, 0x2b94, 0x7c994e9e, 0xfc994e9e, 0x3000080}, +{0x3000000, 0x2b94, 0x6164bd6c, 0xe164bd6c, 0x3000080}, +{0x3000000, 0x2b94, 0x9503366, 0x89503366, 0x3000080}, +{0x3000000, 0x2b94, 0xbf5a97c9, 0x3f5a97c9, 0x3000080}, +{0x3000000, 0x2b94, 0xe6ff1a14, 0x66ff1a14, 0x3000080}, +{0x3000000, 0x2b94, 0x77f31e2f, 0xf7f31e2f, 0x3000080}, +{0x3000000, 0x2b94, 0xaab4d7d8, 0x2ab4d7d8, 0x3000080}, +{0x3000000, 0x2b94, 0x966320b, 0x8966320b, 0x3000080}, +{0x3000000, 0x2b94, 0xb26bddee, 0x326bddee, 0x3000080}, +{0x3000000, 0x2b94, 0xb5c8e5d3, 0x35c8e5d3, 0x3000080}, +{0x3000000, 0x2b94, 0x317285d3, 0xb17285d3, 0x3000080}, +{0x3000000, 0x2b94, 0x3c9623b1, 0xbc9623b1, 0x3000080}, +{0x3000000, 0x2b94, 0x51fd2c7c, 0xd1fd2c7c, 0x3000080}, +{0x3000000, 0x2b94, 0x7b906a6c, 0xfb906a6c, 0x3000080}, +{0x3000000, 0x636d24, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x800000, 0x80800000, 0x3000080}, +{0x3000000, 0x636d24, 0x800002, 0x80800002, 0x3000080}, +{0x3000000, 0x636d24, 0x1398437, 0x81398437, 0x3000080}, +{0x3000000, 0x636d24, 0xba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x636d24, 0xba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x636d24, 0x751f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x636d24, 0x7f7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x636d24, 0x7f7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x636d24, 0x7f800000, 0xff800000, 0x3000080}, +{0x3000000, 0x636d24, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x636d24, 0x80800000, 0x800000, 0x3000080}, +{0x3000000, 0x636d24, 0x80800002, 0x800002, 0x3000080}, +{0x3000000, 0x636d24, 0x81398437, 0x1398437, 0x3000080}, +{0x3000000, 0x636d24, 0x8ba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x636d24, 0x8ba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x636d24, 0xf51f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x636d24, 0xff7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x636d24, 0xff7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x636d24, 0xff800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x636d24, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x636d24, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x636d24, 0x4f3495cb, 0xcf3495cb, 0x3000080}, +{0x3000000, 0x636d24, 0xe73a5134, 0x673a5134, 0x3000080}, +{0x3000000, 0x636d24, 0x7c994e9e, 0xfc994e9e, 0x3000080}, +{0x3000000, 0x636d24, 0x6164bd6c, 0xe164bd6c, 0x3000080}, +{0x3000000, 0x636d24, 0x9503366, 0x89503366, 0x3000080}, +{0x3000000, 0x636d24, 0xbf5a97c9, 0x3f5a97c9, 0x3000080}, +{0x3000000, 0x636d24, 0xe6ff1a14, 0x66ff1a14, 0x3000080}, +{0x3000000, 0x636d24, 0x77f31e2f, 0xf7f31e2f, 0x3000080}, +{0x3000000, 0x636d24, 0xaab4d7d8, 0x2ab4d7d8, 0x3000080}, +{0x3000000, 0x636d24, 0x966320b, 0x8966320b, 0x3000080}, +{0x3000000, 0x636d24, 0xb26bddee, 0x326bddee, 0x3000080}, +{0x3000000, 0x636d24, 0xb5c8e5d3, 0x35c8e5d3, 0x3000080}, +{0x3000000, 0x636d24, 0x317285d3, 0xb17285d3, 0x3000080}, +{0x3000000, 0x636d24, 0x3c9623b1, 0xbc9623b1, 0x3000080}, +{0x3000000, 0x636d24, 0x51fd2c7c, 0xd1fd2c7c, 0x3000080}, +{0x3000000, 0x636d24, 0x7b906a6c, 0xfb906a6c, 0x3000080}, +{0x3000000, 0x7fffff, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x800000, 0x80800000, 0x3000080}, +{0x3000000, 0x7fffff, 0x800002, 0x80800002, 0x3000080}, +{0x3000000, 0x7fffff, 0x1398437, 0x81398437, 0x3000080}, +{0x3000000, 0x7fffff, 0xba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x7fffff, 0xba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x7fffff, 0x751f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x7fffff, 0x7f7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x7fffff, 0x7f7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x7fffff, 0x7f800000, 0xff800000, 0x3000080}, +{0x3000000, 0x7fffff, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x7fffff, 0x80800000, 0x800000, 0x3000080}, +{0x3000000, 0x7fffff, 0x80800002, 0x800002, 0x3000080}, +{0x3000000, 0x7fffff, 0x81398437, 0x1398437, 0x3000080}, +{0x3000000, 0x7fffff, 0x8ba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x7fffff, 0x8ba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x7fffff, 0xf51f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x7fffff, 0xff7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7fffff, 0xff7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7fffff, 0xff800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x7fffff, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fffff, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffff, 0x4f3495cb, 0xcf3495cb, 0x3000080}, +{0x3000000, 0x7fffff, 0xe73a5134, 0x673a5134, 0x3000080}, +{0x3000000, 0x7fffff, 0x7c994e9e, 0xfc994e9e, 0x3000080}, +{0x3000000, 0x7fffff, 0x6164bd6c, 0xe164bd6c, 0x3000080}, +{0x3000000, 0x7fffff, 0x9503366, 0x89503366, 0x3000080}, +{0x3000000, 0x7fffff, 0xbf5a97c9, 0x3f5a97c9, 0x3000080}, +{0x3000000, 0x7fffff, 0xe6ff1a14, 0x66ff1a14, 0x3000080}, +{0x3000000, 0x7fffff, 0x77f31e2f, 0xf7f31e2f, 0x3000080}, +{0x3000000, 0x7fffff, 0xaab4d7d8, 0x2ab4d7d8, 0x3000080}, +{0x3000000, 0x7fffff, 0x966320b, 0x8966320b, 0x3000080}, +{0x3000000, 0x7fffff, 0xb26bddee, 0x326bddee, 0x3000080}, +{0x3000000, 0x7fffff, 0xb5c8e5d3, 0x35c8e5d3, 0x3000080}, +{0x3000000, 0x7fffff, 0x317285d3, 0xb17285d3, 0x3000080}, +{0x3000000, 0x7fffff, 0x3c9623b1, 0xbc9623b1, 0x3000080}, +{0x3000000, 0x7fffff, 0x51fd2c7c, 0xd1fd2c7c, 0x3000080}, +{0x3000000, 0x7fffff, 0x7b906a6c, 0xfb906a6c, 0x3000080}, +{0x3000000, 0x800000, 0x0, 0x800000, 0x3000000}, +{0x3000000, 0x800000, 0x1, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x76, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x2b94, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x636d24, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x7fffff, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x800000, 0x0, 0x3000000}, +{0x3000000, 0x800000, 0x800002, 0x0, 0x3000008}, +{0x3000000, 0x800000, 0x1398437, 0x80f3086e, 0x3000000}, +{0x3000000, 0x800000, 0xba98d27, 0x8ba98d25, 0x3000000}, +{0x3000000, 0x800000, 0xba98d7a, 0x8ba98d78, 0x3000000}, +{0x3000000, 0x800000, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x800000, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x800000, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x800000, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x800000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0x80000000, 0x800000, 0x3000000}, +{0x3000000, 0x800000, 0x80000001, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x80000076, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x80002b94, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x80636d24, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x807fffff, 0x800000, 0x3000080}, +{0x3000000, 0x800000, 0x80800000, 0x1000000, 0x3000000}, +{0x3000000, 0x800000, 0x80800002, 0x1000001, 0x3000000}, +{0x3000000, 0x800000, 0x81398437, 0x1798437, 0x3000000}, +{0x3000000, 0x800000, 0x8ba98d27, 0xba98d29, 0x3000000}, +{0x3000000, 0x800000, 0x8ba98d7a, 0xba98d7c, 0x3000000}, +{0x3000000, 0x800000, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x800000, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x800000, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x800000, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x800000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800000, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x800000, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x800000, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x800000, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x800000, 0x9503366, 0x89503326, 0x3000000}, +{0x3000000, 0x800000, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x800000, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x800000, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x800000, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0x800000, 0x966320b, 0x896631cb, 0x3000000}, +{0x3000000, 0x800000, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0x800000, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0x800000, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0x800000, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0x800000, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x800000, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x800002, 0x0, 0x800002, 0x3000000}, +{0x3000000, 0x800002, 0x1, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x76, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x2b94, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x636d24, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x7fffff, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x800000, 0x0, 0x3000008}, +{0x3000000, 0x800002, 0x800002, 0x0, 0x3000000}, +{0x3000000, 0x800002, 0x1398437, 0x80f3086c, 0x3000000}, +{0x3000000, 0x800002, 0xba98d27, 0x8ba98d25, 0x3000010}, +{0x3000000, 0x800002, 0xba98d7a, 0x8ba98d78, 0x3000010}, +{0x3000000, 0x800002, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x800002, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x800002, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x800002, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x800002, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0x80000000, 0x800002, 0x3000000}, +{0x3000000, 0x800002, 0x80000001, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x80000076, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x80002b94, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x80636d24, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x807fffff, 0x800002, 0x3000080}, +{0x3000000, 0x800002, 0x80800000, 0x1000001, 0x3000000}, +{0x3000000, 0x800002, 0x80800002, 0x1000002, 0x3000000}, +{0x3000000, 0x800002, 0x81398437, 0x1798438, 0x3000000}, +{0x3000000, 0x800002, 0x8ba98d27, 0xba98d29, 0x3000010}, +{0x3000000, 0x800002, 0x8ba98d7a, 0xba98d7c, 0x3000010}, +{0x3000000, 0x800002, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x800002, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x800002, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x800002, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x800002, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x800002, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x800002, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x800002, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x800002, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x800002, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x800002, 0x9503366, 0x89503326, 0x3000010}, +{0x3000000, 0x800002, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x800002, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x800002, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x800002, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0x800002, 0x966320b, 0x896631cb, 0x3000010}, +{0x3000000, 0x800002, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0x800002, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0x800002, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0x800002, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0x800002, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x800002, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x1398437, 0x0, 0x1398437, 0x3000000}, +{0x3000000, 0x1398437, 0x1, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x76, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x2b94, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x636d24, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x7fffff, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x800000, 0xf3086e, 0x3000000}, +{0x3000000, 0x1398437, 0x800002, 0xf3086c, 0x3000000}, +{0x3000000, 0x1398437, 0x1398437, 0x0, 0x3000000}, +{0x3000000, 0x1398437, 0xba98d27, 0x8ba98d21, 0x3000010}, +{0x3000000, 0x1398437, 0xba98d7a, 0x8ba98d74, 0x3000010}, +{0x3000000, 0x1398437, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x1398437, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x1398437, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x1398437, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x1398437, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0x80000000, 0x1398437, 0x3000000}, +{0x3000000, 0x1398437, 0x80000001, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x80000076, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x80002b94, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x80636d24, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x807fffff, 0x1398437, 0x3000080}, +{0x3000000, 0x1398437, 0x80800000, 0x1798437, 0x3000000}, +{0x3000000, 0x1398437, 0x80800002, 0x1798438, 0x3000000}, +{0x3000000, 0x1398437, 0x81398437, 0x1b98437, 0x3000000}, +{0x3000000, 0x1398437, 0x8ba98d27, 0xba98d2d, 0x3000010}, +{0x3000000, 0x1398437, 0x8ba98d7a, 0xba98d80, 0x3000010}, +{0x3000000, 0x1398437, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x1398437, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x1398437, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x1398437, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x1398437, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x1398437, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x1398437, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x1398437, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x1398437, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x1398437, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x1398437, 0x9503366, 0x895032ac, 0x3000010}, +{0x3000000, 0x1398437, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x1398437, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x1398437, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x1398437, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0x1398437, 0x966320b, 0x89663151, 0x3000010}, +{0x3000000, 0x1398437, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0x1398437, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0x1398437, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0x1398437, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0x1398437, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x1398437, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0xba98d27, 0x0, 0xba98d27, 0x3000000}, +{0x3000000, 0xba98d27, 0x1, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x76, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x2b94, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x636d24, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x7fffff, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x800000, 0xba98d25, 0x3000000}, +{0x3000000, 0xba98d27, 0x800002, 0xba98d25, 0x3000010}, +{0x3000000, 0xba98d27, 0x1398437, 0xba98d21, 0x3000010}, +{0x3000000, 0xba98d27, 0xba98d27, 0x0, 0x3000000}, +{0x3000000, 0xba98d27, 0xba98d7a, 0x83260000, 0x3000000}, +{0x3000000, 0xba98d27, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xba98d27, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xba98d27, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xba98d27, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xba98d27, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0x80000000, 0xba98d27, 0x3000000}, +{0x3000000, 0xba98d27, 0x80000001, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x80000076, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x80002b94, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x80636d24, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x807fffff, 0xba98d27, 0x3000080}, +{0x3000000, 0xba98d27, 0x80800000, 0xba98d29, 0x3000000}, +{0x3000000, 0xba98d27, 0x80800002, 0xba98d29, 0x3000010}, +{0x3000000, 0xba98d27, 0x81398437, 0xba98d2d, 0x3000010}, +{0x3000000, 0xba98d27, 0x8ba98d27, 0xc298d27, 0x3000000}, +{0x3000000, 0xba98d27, 0x8ba98d7a, 0xc298d50, 0x3000010}, +{0x3000000, 0xba98d27, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xba98d27, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xba98d27, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xba98d27, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xba98d27, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d27, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d27, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0xba98d27, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0xba98d27, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0xba98d27, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0xba98d27, 0x9503366, 0xba30b8c, 0x3000010}, +{0x3000000, 0xba98d27, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0xba98d27, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0xba98d27, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0xba98d27, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0xba98d27, 0x966320b, 0xba25b97, 0x3000010}, +{0x3000000, 0xba98d27, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0xba98d27, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0xba98d27, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0xba98d27, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0xba98d27, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0xba98d27, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0xba98d7a, 0x0, 0xba98d7a, 0x3000000}, +{0x3000000, 0xba98d7a, 0x1, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x76, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x2b94, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x636d24, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x7fffff, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x800000, 0xba98d78, 0x3000000}, +{0x3000000, 0xba98d7a, 0x800002, 0xba98d78, 0x3000010}, +{0x3000000, 0xba98d7a, 0x1398437, 0xba98d74, 0x3000010}, +{0x3000000, 0xba98d7a, 0xba98d27, 0x3260000, 0x3000000}, +{0x3000000, 0xba98d7a, 0xba98d7a, 0x0, 0x3000000}, +{0x3000000, 0xba98d7a, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xba98d7a, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xba98d7a, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xba98d7a, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x80000000, 0xba98d7a, 0x3000000}, +{0x3000000, 0xba98d7a, 0x80000001, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x80000076, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x80002b94, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x80636d24, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x807fffff, 0xba98d7a, 0x3000080}, +{0x3000000, 0xba98d7a, 0x80800000, 0xba98d7c, 0x3000000}, +{0x3000000, 0xba98d7a, 0x80800002, 0xba98d7c, 0x3000010}, +{0x3000000, 0xba98d7a, 0x81398437, 0xba98d80, 0x3000010}, +{0x3000000, 0xba98d7a, 0x8ba98d27, 0xc298d50, 0x3000010}, +{0x3000000, 0xba98d7a, 0x8ba98d7a, 0xc298d7a, 0x3000000}, +{0x3000000, 0xba98d7a, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xba98d7a, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xba98d7a, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xba98d7a, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xba98d7a, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xba98d7a, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xba98d7a, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0xba98d7a, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0xba98d7a, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0xba98d7a, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0xba98d7a, 0x9503366, 0xba30bdf, 0x3000010}, +{0x3000000, 0xba98d7a, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0xba98d7a, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0xba98d7a, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0xba98d7a, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0xba98d7a, 0x966320b, 0xba25bea, 0x3000010}, +{0x3000000, 0xba98d7a, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0xba98d7a, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0xba98d7a, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0xba98d7a, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0xba98d7a, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0xba98d7a, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x751f853a, 0x0, 0x751f853a, 0x3000000}, +{0x3000000, 0x751f853a, 0x1, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x76, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x2b94, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x636d24, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x7fffff, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x800000, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x800002, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x1398437, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xba98d27, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xba98d7a, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x751f853a, 0x0, 0x3000000}, +{0x3000000, 0x751f853a, 0x7f7ffff0, 0xff7fffe6, 0x3000010}, +{0x3000000, 0x751f853a, 0x7f7fffff, 0xff7ffff5, 0x3000010}, +{0x3000000, 0x751f853a, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x751f853a, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0x80000000, 0x751f853a, 0x3000000}, +{0x3000000, 0x751f853a, 0x80000001, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x80000076, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x80002b94, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x80636d24, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x807fffff, 0x751f853a, 0x3000080}, +{0x3000000, 0x751f853a, 0x80800000, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x80800002, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x81398437, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x8ba98d27, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x8ba98d7a, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xf51f853a, 0x759f853a, 0x3000000}, +{0x3000000, 0x751f853a, 0xff7ffff0, 0x7f7ffffa, 0x3000010}, +{0x3000000, 0x751f853a, 0xff7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x751f853a, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x751f853a, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x751f853a, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x751f853a, 0x4f3495cb, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xe73a5134, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x7c994e9e, 0xfc994d5f, 0x3000010}, +{0x3000000, 0x751f853a, 0x6164bd6c, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x9503366, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xbf5a97c9, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xe6ff1a14, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x77f31e2f, 0xf7ee2205, 0x3000010}, +{0x3000000, 0x751f853a, 0xaab4d7d8, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x966320b, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xb26bddee, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0xb5c8e5d3, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x317285d3, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x3c9623b1, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x51fd2c7c, 0x751f853a, 0x3000010}, +{0x3000000, 0x751f853a, 0x7b906a6c, 0xfb906570, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x0, 0x7f7ffff0, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x1, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x76, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x2b94, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x636d24, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x7fffff, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x800000, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x800002, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x1398437, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xba98d27, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xba98d7a, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x751f853a, 0x7f7fffe6, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x7f7ffff0, 0x0, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x7f7fffff, 0xf5700000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x80000000, 0x7f7ffff0, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x80000001, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x80000076, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x80002b94, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x80636d24, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x807fffff, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x7f7ffff0, 0x80800000, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x80800002, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x81398437, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x8ba98d27, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x8ba98d7a, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xf51f853a, 0x7f7ffffa, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xff7ffff0, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7ffff0, 0xff7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7ffff0, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7ffff0, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7ffff0, 0x4f3495cb, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xe73a5134, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x7c994e9e, 0x7f7b357b, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x6164bd6c, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x9503366, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xbf5a97c9, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xe6ff1a14, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x77f31e2f, 0x7f7ffe0a, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xaab4d7d8, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x966320b, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xb26bddee, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0xb5c8e5d3, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x317285d3, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x3c9623b1, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x51fd2c7c, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x7f7ffff0, 0x7b906a6c, 0x7f7edf1b, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x0, 0x7f7fffff, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x1, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x76, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x2b94, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x636d24, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x800000, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x800002, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x1398437, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xba98d27, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xba98d7a, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x751f853a, 0x7f7ffff5, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x7f7ffff0, 0x75700000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x7f7fffff, 0x0, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x80000000, 0x7f7fffff, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x80000001, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x80000076, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x80002b94, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x80636d24, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x807fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x7f7fffff, 0x80800000, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x80800002, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x81398437, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x8ba98d27, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x8ba98d7a, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xf51f853a, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7fffff, 0xff7ffff0, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7fffff, 0xff7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x7f7fffff, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f7fffff, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f7fffff, 0x4f3495cb, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xe73a5134, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x7c994e9e, 0x7f7b358a, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x6164bd6c, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x9503366, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xbf5a97c9, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xe6ff1a14, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x77f31e2f, 0x7f7ffe19, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xaab4d7d8, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x966320b, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xb26bddee, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0xb5c8e5d3, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x317285d3, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x3c9623b1, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x51fd2c7c, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x7f7fffff, 0x7b906a6c, 0x7f7edf2a, 0x3000010}, +{0x3000000, 0x7f800000, 0x0, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x1, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x76, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x2b94, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x636d24, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x7fffff, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x800002, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x1398437, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xba98d27, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xba98d7a, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x751f853a, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7f7ffff0, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7f7fffff, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0x80000000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x80000001, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x80000076, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x80002b94, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x80636d24, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x807fffff, 0x7f800000, 0x3000080}, +{0x3000000, 0x7f800000, 0x80800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x80800002, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x81398437, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x8ba98d27, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x8ba98d7a, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xf51f853a, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xff7ffff0, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xff7fffff, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7f800000, 0x4f3495cb, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xe73a5134, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7c994e9e, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x6164bd6c, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x9503366, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xbf5a97c9, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xe6ff1a14, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x77f31e2f, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xaab4d7d8, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x966320b, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xb26bddee, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0xb5c8e5d3, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x317285d3, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x3c9623b1, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x51fd2c7c, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800000, 0x7b906a6c, 0x7f800000, 0x3000000}, +{0x3000000, 0x7f800001, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f800001, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f800001, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7f984a37, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7f984a37, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x7fbfffff, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fbfffff, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fc00000, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fc00000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fc00000, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fd9ba98, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fd9ba98, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fd9ba98, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x7fffffff, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7fffffff, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7fffffff, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0x0, 0x80000000, 0x3000000}, +{0x3000000, 0x80000000, 0x1, 0x80000000, 0x3000080}, +{0x3000000, 0x80000000, 0x76, 0x80000000, 0x3000080}, +{0x3000000, 0x80000000, 0x2b94, 0x80000000, 0x3000080}, +{0x3000000, 0x80000000, 0x636d24, 0x80000000, 0x3000080}, +{0x3000000, 0x80000000, 0x7fffff, 0x80000000, 0x3000080}, +{0x3000000, 0x80000000, 0x800000, 0x80800000, 0x3000000}, +{0x3000000, 0x80000000, 0x800002, 0x80800002, 0x3000000}, +{0x3000000, 0x80000000, 0x1398437, 0x81398437, 0x3000000}, +{0x3000000, 0x80000000, 0xba98d27, 0x8ba98d27, 0x3000000}, +{0x3000000, 0x80000000, 0xba98d7a, 0x8ba98d7a, 0x3000000}, +{0x3000000, 0x80000000, 0x751f853a, 0xf51f853a, 0x3000000}, +{0x3000000, 0x80000000, 0x7f7ffff0, 0xff7ffff0, 0x3000000}, +{0x3000000, 0x80000000, 0x7f7fffff, 0xff7fffff, 0x3000000}, +{0x3000000, 0x80000000, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x80000000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0x80000000, 0x0, 0x3000000}, +{0x3000000, 0x80000000, 0x80000001, 0x80000000, 0x3000080}, +{0x3000000, 0x80000000, 0x80000076, 0x80000000, 0x3000080}, +{0x3000000, 0x80000000, 0x80002b94, 0x80000000, 0x3000080}, +{0x3000000, 0x80000000, 0x80636d24, 0x80000000, 0x3000080}, +{0x3000000, 0x80000000, 0x807fffff, 0x80000000, 0x3000080}, +{0x3000000, 0x80000000, 0x80800000, 0x800000, 0x3000000}, +{0x3000000, 0x80000000, 0x80800002, 0x800002, 0x3000000}, +{0x3000000, 0x80000000, 0x81398437, 0x1398437, 0x3000000}, +{0x3000000, 0x80000000, 0x8ba98d27, 0xba98d27, 0x3000000}, +{0x3000000, 0x80000000, 0x8ba98d7a, 0xba98d7a, 0x3000000}, +{0x3000000, 0x80000000, 0xf51f853a, 0x751f853a, 0x3000000}, +{0x3000000, 0x80000000, 0xff7ffff0, 0x7f7ffff0, 0x3000000}, +{0x3000000, 0x80000000, 0xff7fffff, 0x7f7fffff, 0x3000000}, +{0x3000000, 0x80000000, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x80000000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80000000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80000000, 0x4f3495cb, 0xcf3495cb, 0x3000000}, +{0x3000000, 0x80000000, 0xe73a5134, 0x673a5134, 0x3000000}, +{0x3000000, 0x80000000, 0x7c994e9e, 0xfc994e9e, 0x3000000}, +{0x3000000, 0x80000000, 0x6164bd6c, 0xe164bd6c, 0x3000000}, +{0x3000000, 0x80000000, 0x9503366, 0x89503366, 0x3000000}, +{0x3000000, 0x80000000, 0xbf5a97c9, 0x3f5a97c9, 0x3000000}, +{0x3000000, 0x80000000, 0xe6ff1a14, 0x66ff1a14, 0x3000000}, +{0x3000000, 0x80000000, 0x77f31e2f, 0xf7f31e2f, 0x3000000}, +{0x3000000, 0x80000000, 0xaab4d7d8, 0x2ab4d7d8, 0x3000000}, +{0x3000000, 0x80000000, 0x966320b, 0x8966320b, 0x3000000}, +{0x3000000, 0x80000000, 0xb26bddee, 0x326bddee, 0x3000000}, +{0x3000000, 0x80000000, 0xb5c8e5d3, 0x35c8e5d3, 0x3000000}, +{0x3000000, 0x80000000, 0x317285d3, 0xb17285d3, 0x3000000}, +{0x3000000, 0x80000000, 0x3c9623b1, 0xbc9623b1, 0x3000000}, +{0x3000000, 0x80000000, 0x51fd2c7c, 0xd1fd2c7c, 0x3000000}, +{0x3000000, 0x80000000, 0x7b906a6c, 0xfb906a6c, 0x3000000}, +{0x3000000, 0x80000001, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x800000, 0x80800000, 0x3000080}, +{0x3000000, 0x80000001, 0x800002, 0x80800002, 0x3000080}, +{0x3000000, 0x80000001, 0x1398437, 0x81398437, 0x3000080}, +{0x3000000, 0x80000001, 0xba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x80000001, 0xba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x80000001, 0x751f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x80000001, 0x7f7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x80000001, 0x7f7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x80000001, 0x7f800000, 0xff800000, 0x3000080}, +{0x3000000, 0x80000001, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x80000001, 0x80800000, 0x800000, 0x3000080}, +{0x3000000, 0x80000001, 0x80800002, 0x800002, 0x3000080}, +{0x3000000, 0x80000001, 0x81398437, 0x1398437, 0x3000080}, +{0x3000000, 0x80000001, 0x8ba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x80000001, 0x8ba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x80000001, 0xf51f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x80000001, 0xff7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x80000001, 0xff7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x80000001, 0xff800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x80000001, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000001, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000001, 0x4f3495cb, 0xcf3495cb, 0x3000080}, +{0x3000000, 0x80000001, 0xe73a5134, 0x673a5134, 0x3000080}, +{0x3000000, 0x80000001, 0x7c994e9e, 0xfc994e9e, 0x3000080}, +{0x3000000, 0x80000001, 0x6164bd6c, 0xe164bd6c, 0x3000080}, +{0x3000000, 0x80000001, 0x9503366, 0x89503366, 0x3000080}, +{0x3000000, 0x80000001, 0xbf5a97c9, 0x3f5a97c9, 0x3000080}, +{0x3000000, 0x80000001, 0xe6ff1a14, 0x66ff1a14, 0x3000080}, +{0x3000000, 0x80000001, 0x77f31e2f, 0xf7f31e2f, 0x3000080}, +{0x3000000, 0x80000001, 0xaab4d7d8, 0x2ab4d7d8, 0x3000080}, +{0x3000000, 0x80000001, 0x966320b, 0x8966320b, 0x3000080}, +{0x3000000, 0x80000001, 0xb26bddee, 0x326bddee, 0x3000080}, +{0x3000000, 0x80000001, 0xb5c8e5d3, 0x35c8e5d3, 0x3000080}, +{0x3000000, 0x80000001, 0x317285d3, 0xb17285d3, 0x3000080}, +{0x3000000, 0x80000001, 0x3c9623b1, 0xbc9623b1, 0x3000080}, +{0x3000000, 0x80000001, 0x51fd2c7c, 0xd1fd2c7c, 0x3000080}, +{0x3000000, 0x80000001, 0x7b906a6c, 0xfb906a6c, 0x3000080}, +{0x3000000, 0x80000076, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x800000, 0x80800000, 0x3000080}, +{0x3000000, 0x80000076, 0x800002, 0x80800002, 0x3000080}, +{0x3000000, 0x80000076, 0x1398437, 0x81398437, 0x3000080}, +{0x3000000, 0x80000076, 0xba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x80000076, 0xba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x80000076, 0x751f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x80000076, 0x7f7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x80000076, 0x7f7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x80000076, 0x7f800000, 0xff800000, 0x3000080}, +{0x3000000, 0x80000076, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x80000076, 0x80800000, 0x800000, 0x3000080}, +{0x3000000, 0x80000076, 0x80800002, 0x800002, 0x3000080}, +{0x3000000, 0x80000076, 0x81398437, 0x1398437, 0x3000080}, +{0x3000000, 0x80000076, 0x8ba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x80000076, 0x8ba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x80000076, 0xf51f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x80000076, 0xff7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x80000076, 0xff7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x80000076, 0xff800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x80000076, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80000076, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80000076, 0x4f3495cb, 0xcf3495cb, 0x3000080}, +{0x3000000, 0x80000076, 0xe73a5134, 0x673a5134, 0x3000080}, +{0x3000000, 0x80000076, 0x7c994e9e, 0xfc994e9e, 0x3000080}, +{0x3000000, 0x80000076, 0x6164bd6c, 0xe164bd6c, 0x3000080}, +{0x3000000, 0x80000076, 0x9503366, 0x89503366, 0x3000080}, +{0x3000000, 0x80000076, 0xbf5a97c9, 0x3f5a97c9, 0x3000080}, +{0x3000000, 0x80000076, 0xe6ff1a14, 0x66ff1a14, 0x3000080}, +{0x3000000, 0x80000076, 0x77f31e2f, 0xf7f31e2f, 0x3000080}, +{0x3000000, 0x80000076, 0xaab4d7d8, 0x2ab4d7d8, 0x3000080}, +{0x3000000, 0x80000076, 0x966320b, 0x8966320b, 0x3000080}, +{0x3000000, 0x80000076, 0xb26bddee, 0x326bddee, 0x3000080}, +{0x3000000, 0x80000076, 0xb5c8e5d3, 0x35c8e5d3, 0x3000080}, +{0x3000000, 0x80000076, 0x317285d3, 0xb17285d3, 0x3000080}, +{0x3000000, 0x80000076, 0x3c9623b1, 0xbc9623b1, 0x3000080}, +{0x3000000, 0x80000076, 0x51fd2c7c, 0xd1fd2c7c, 0x3000080}, +{0x3000000, 0x80000076, 0x7b906a6c, 0xfb906a6c, 0x3000080}, +{0x3000000, 0x80002b94, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x800000, 0x80800000, 0x3000080}, +{0x3000000, 0x80002b94, 0x800002, 0x80800002, 0x3000080}, +{0x3000000, 0x80002b94, 0x1398437, 0x81398437, 0x3000080}, +{0x3000000, 0x80002b94, 0xba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x80002b94, 0xba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x80002b94, 0x751f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x80002b94, 0x7f7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x80002b94, 0x7f7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x80002b94, 0x7f800000, 0xff800000, 0x3000080}, +{0x3000000, 0x80002b94, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x80002b94, 0x80800000, 0x800000, 0x3000080}, +{0x3000000, 0x80002b94, 0x80800002, 0x800002, 0x3000080}, +{0x3000000, 0x80002b94, 0x81398437, 0x1398437, 0x3000080}, +{0x3000000, 0x80002b94, 0x8ba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x80002b94, 0x8ba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x80002b94, 0xf51f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x80002b94, 0xff7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x80002b94, 0xff7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x80002b94, 0xff800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x80002b94, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80002b94, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80002b94, 0x4f3495cb, 0xcf3495cb, 0x3000080}, +{0x3000000, 0x80002b94, 0xe73a5134, 0x673a5134, 0x3000080}, +{0x3000000, 0x80002b94, 0x7c994e9e, 0xfc994e9e, 0x3000080}, +{0x3000000, 0x80002b94, 0x6164bd6c, 0xe164bd6c, 0x3000080}, +{0x3000000, 0x80002b94, 0x9503366, 0x89503366, 0x3000080}, +{0x3000000, 0x80002b94, 0xbf5a97c9, 0x3f5a97c9, 0x3000080}, +{0x3000000, 0x80002b94, 0xe6ff1a14, 0x66ff1a14, 0x3000080}, +{0x3000000, 0x80002b94, 0x77f31e2f, 0xf7f31e2f, 0x3000080}, +{0x3000000, 0x80002b94, 0xaab4d7d8, 0x2ab4d7d8, 0x3000080}, +{0x3000000, 0x80002b94, 0x966320b, 0x8966320b, 0x3000080}, +{0x3000000, 0x80002b94, 0xb26bddee, 0x326bddee, 0x3000080}, +{0x3000000, 0x80002b94, 0xb5c8e5d3, 0x35c8e5d3, 0x3000080}, +{0x3000000, 0x80002b94, 0x317285d3, 0xb17285d3, 0x3000080}, +{0x3000000, 0x80002b94, 0x3c9623b1, 0xbc9623b1, 0x3000080}, +{0x3000000, 0x80002b94, 0x51fd2c7c, 0xd1fd2c7c, 0x3000080}, +{0x3000000, 0x80002b94, 0x7b906a6c, 0xfb906a6c, 0x3000080}, +{0x3000000, 0x80636d24, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x800000, 0x80800000, 0x3000080}, +{0x3000000, 0x80636d24, 0x800002, 0x80800002, 0x3000080}, +{0x3000000, 0x80636d24, 0x1398437, 0x81398437, 0x3000080}, +{0x3000000, 0x80636d24, 0xba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x80636d24, 0xba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x80636d24, 0x751f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x80636d24, 0x7f7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x80636d24, 0x7f7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x80636d24, 0x7f800000, 0xff800000, 0x3000080}, +{0x3000000, 0x80636d24, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x80636d24, 0x80800000, 0x800000, 0x3000080}, +{0x3000000, 0x80636d24, 0x80800002, 0x800002, 0x3000080}, +{0x3000000, 0x80636d24, 0x81398437, 0x1398437, 0x3000080}, +{0x3000000, 0x80636d24, 0x8ba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x80636d24, 0x8ba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x80636d24, 0xf51f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x80636d24, 0xff7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x80636d24, 0xff7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x80636d24, 0xff800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x80636d24, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x80636d24, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x80636d24, 0x4f3495cb, 0xcf3495cb, 0x3000080}, +{0x3000000, 0x80636d24, 0xe73a5134, 0x673a5134, 0x3000080}, +{0x3000000, 0x80636d24, 0x7c994e9e, 0xfc994e9e, 0x3000080}, +{0x3000000, 0x80636d24, 0x6164bd6c, 0xe164bd6c, 0x3000080}, +{0x3000000, 0x80636d24, 0x9503366, 0x89503366, 0x3000080}, +{0x3000000, 0x80636d24, 0xbf5a97c9, 0x3f5a97c9, 0x3000080}, +{0x3000000, 0x80636d24, 0xe6ff1a14, 0x66ff1a14, 0x3000080}, +{0x3000000, 0x80636d24, 0x77f31e2f, 0xf7f31e2f, 0x3000080}, +{0x3000000, 0x80636d24, 0xaab4d7d8, 0x2ab4d7d8, 0x3000080}, +{0x3000000, 0x80636d24, 0x966320b, 0x8966320b, 0x3000080}, +{0x3000000, 0x80636d24, 0xb26bddee, 0x326bddee, 0x3000080}, +{0x3000000, 0x80636d24, 0xb5c8e5d3, 0x35c8e5d3, 0x3000080}, +{0x3000000, 0x80636d24, 0x317285d3, 0xb17285d3, 0x3000080}, +{0x3000000, 0x80636d24, 0x3c9623b1, 0xbc9623b1, 0x3000080}, +{0x3000000, 0x80636d24, 0x51fd2c7c, 0xd1fd2c7c, 0x3000080}, +{0x3000000, 0x80636d24, 0x7b906a6c, 0xfb906a6c, 0x3000080}, +{0x3000000, 0x807fffff, 0x0, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x1, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x76, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x2b94, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x636d24, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x7fffff, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x800000, 0x80800000, 0x3000080}, +{0x3000000, 0x807fffff, 0x800002, 0x80800002, 0x3000080}, +{0x3000000, 0x807fffff, 0x1398437, 0x81398437, 0x3000080}, +{0x3000000, 0x807fffff, 0xba98d27, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x807fffff, 0xba98d7a, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x807fffff, 0x751f853a, 0xf51f853a, 0x3000080}, +{0x3000000, 0x807fffff, 0x7f7ffff0, 0xff7ffff0, 0x3000080}, +{0x3000000, 0x807fffff, 0x7f7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0x807fffff, 0x7f800000, 0xff800000, 0x3000080}, +{0x3000000, 0x807fffff, 0x7f800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0x7f984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0x7fbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0x7fc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0x7fd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0x7fffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0x80000000, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x80000001, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x80000076, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x80002b94, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x80636d24, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x807fffff, 0x0, 0x3000080}, +{0x3000000, 0x807fffff, 0x80800000, 0x800000, 0x3000080}, +{0x3000000, 0x807fffff, 0x80800002, 0x800002, 0x3000080}, +{0x3000000, 0x807fffff, 0x81398437, 0x1398437, 0x3000080}, +{0x3000000, 0x807fffff, 0x8ba98d27, 0xba98d27, 0x3000080}, +{0x3000000, 0x807fffff, 0x8ba98d7a, 0xba98d7a, 0x3000080}, +{0x3000000, 0x807fffff, 0xf51f853a, 0x751f853a, 0x3000080}, +{0x3000000, 0x807fffff, 0xff7ffff0, 0x7f7ffff0, 0x3000080}, +{0x3000000, 0x807fffff, 0xff7fffff, 0x7f7fffff, 0x3000080}, +{0x3000000, 0x807fffff, 0xff800000, 0x7f800000, 0x3000080}, +{0x3000000, 0x807fffff, 0xff800001, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0xff984a37, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0xffbfffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0x807fffff, 0xffc00000, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0xffd9ba98, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0xffffffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0x807fffff, 0x4f3495cb, 0xcf3495cb, 0x3000080}, +{0x3000000, 0x807fffff, 0xe73a5134, 0x673a5134, 0x3000080}, +{0x3000000, 0x807fffff, 0x7c994e9e, 0xfc994e9e, 0x3000080}, +{0x3000000, 0x807fffff, 0x6164bd6c, 0xe164bd6c, 0x3000080}, +{0x3000000, 0x807fffff, 0x9503366, 0x89503366, 0x3000080}, +{0x3000000, 0x807fffff, 0xbf5a97c9, 0x3f5a97c9, 0x3000080}, +{0x3000000, 0x807fffff, 0xe6ff1a14, 0x66ff1a14, 0x3000080}, +{0x3000000, 0x807fffff, 0x77f31e2f, 0xf7f31e2f, 0x3000080}, +{0x3000000, 0x807fffff, 0xaab4d7d8, 0x2ab4d7d8, 0x3000080}, +{0x3000000, 0x807fffff, 0x966320b, 0x8966320b, 0x3000080}, +{0x3000000, 0x807fffff, 0xb26bddee, 0x326bddee, 0x3000080}, +{0x3000000, 0x807fffff, 0xb5c8e5d3, 0x35c8e5d3, 0x3000080}, +{0x3000000, 0x807fffff, 0x317285d3, 0xb17285d3, 0x3000080}, +{0x3000000, 0x807fffff, 0x3c9623b1, 0xbc9623b1, 0x3000080}, +{0x3000000, 0x807fffff, 0x51fd2c7c, 0xd1fd2c7c, 0x3000080}, +{0x3000000, 0x807fffff, 0x7b906a6c, 0xfb906a6c, 0x3000080}, +{0x3000000, 0x80800000, 0x0, 0x80800000, 0x3000000}, +{0x3000000, 0x80800000, 0x1, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x76, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x2b94, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x636d24, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x7fffff, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x800000, 0x81000000, 0x3000000}, +{0x3000000, 0x80800000, 0x800002, 0x81000001, 0x3000000}, +{0x3000000, 0x80800000, 0x1398437, 0x81798437, 0x3000000}, +{0x3000000, 0x80800000, 0xba98d27, 0x8ba98d29, 0x3000000}, +{0x3000000, 0x80800000, 0xba98d7a, 0x8ba98d7c, 0x3000000}, +{0x3000000, 0x80800000, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x80800000, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x80800000, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x80800000, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x80800000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0x80000000, 0x80800000, 0x3000000}, +{0x3000000, 0x80800000, 0x80000001, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x80000076, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x80002b94, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x80636d24, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x807fffff, 0x80800000, 0x3000080}, +{0x3000000, 0x80800000, 0x80800000, 0x0, 0x3000000}, +{0x3000000, 0x80800000, 0x80800002, 0x0, 0x3000008}, +{0x3000000, 0x80800000, 0x81398437, 0xf3086e, 0x3000000}, +{0x3000000, 0x80800000, 0x8ba98d27, 0xba98d25, 0x3000000}, +{0x3000000, 0x80800000, 0x8ba98d7a, 0xba98d78, 0x3000000}, +{0x3000000, 0x80800000, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x80800000, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x80800000, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x80800000, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x80800000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800000, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x80800000, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x80800000, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x80800000, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x80800000, 0x9503366, 0x895033a6, 0x3000000}, +{0x3000000, 0x80800000, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x80800000, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x80800000, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x80800000, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0x80800000, 0x966320b, 0x8966324b, 0x3000000}, +{0x3000000, 0x80800000, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0x80800000, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0x80800000, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0x80800000, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0x80800000, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x80800000, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x80800002, 0x0, 0x80800002, 0x3000000}, +{0x3000000, 0x80800002, 0x1, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x76, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x2b94, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x636d24, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x7fffff, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x800000, 0x81000001, 0x3000000}, +{0x3000000, 0x80800002, 0x800002, 0x81000002, 0x3000000}, +{0x3000000, 0x80800002, 0x1398437, 0x81798438, 0x3000000}, +{0x3000000, 0x80800002, 0xba98d27, 0x8ba98d29, 0x3000010}, +{0x3000000, 0x80800002, 0xba98d7a, 0x8ba98d7c, 0x3000010}, +{0x3000000, 0x80800002, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x80800002, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x80800002, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x80800002, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x80800002, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0x80000000, 0x80800002, 0x3000000}, +{0x3000000, 0x80800002, 0x80000001, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x80000076, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x80002b94, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x80636d24, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x807fffff, 0x80800002, 0x3000080}, +{0x3000000, 0x80800002, 0x80800000, 0x0, 0x3000008}, +{0x3000000, 0x80800002, 0x80800002, 0x0, 0x3000000}, +{0x3000000, 0x80800002, 0x81398437, 0xf3086c, 0x3000000}, +{0x3000000, 0x80800002, 0x8ba98d27, 0xba98d25, 0x3000010}, +{0x3000000, 0x80800002, 0x8ba98d7a, 0xba98d78, 0x3000010}, +{0x3000000, 0x80800002, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x80800002, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x80800002, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x80800002, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x80800002, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x80800002, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x80800002, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x80800002, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x80800002, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x80800002, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x80800002, 0x9503366, 0x895033a6, 0x3000010}, +{0x3000000, 0x80800002, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x80800002, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x80800002, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x80800002, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0x80800002, 0x966320b, 0x8966324b, 0x3000010}, +{0x3000000, 0x80800002, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0x80800002, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0x80800002, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0x80800002, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0x80800002, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x80800002, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x81398437, 0x0, 0x81398437, 0x3000000}, +{0x3000000, 0x81398437, 0x1, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x76, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x2b94, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x636d24, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x7fffff, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x800000, 0x81798437, 0x3000000}, +{0x3000000, 0x81398437, 0x800002, 0x81798438, 0x3000000}, +{0x3000000, 0x81398437, 0x1398437, 0x81b98437, 0x3000000}, +{0x3000000, 0x81398437, 0xba98d27, 0x8ba98d2d, 0x3000010}, +{0x3000000, 0x81398437, 0xba98d7a, 0x8ba98d80, 0x3000010}, +{0x3000000, 0x81398437, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x81398437, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x81398437, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x81398437, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x81398437, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0x80000000, 0x81398437, 0x3000000}, +{0x3000000, 0x81398437, 0x80000001, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x80000076, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x80002b94, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x80636d24, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x807fffff, 0x81398437, 0x3000080}, +{0x3000000, 0x81398437, 0x80800000, 0x80f3086e, 0x3000000}, +{0x3000000, 0x81398437, 0x80800002, 0x80f3086c, 0x3000000}, +{0x3000000, 0x81398437, 0x81398437, 0x0, 0x3000000}, +{0x3000000, 0x81398437, 0x8ba98d27, 0xba98d21, 0x3000010}, +{0x3000000, 0x81398437, 0x8ba98d7a, 0xba98d74, 0x3000010}, +{0x3000000, 0x81398437, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x81398437, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x81398437, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x81398437, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x81398437, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x81398437, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x81398437, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x81398437, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x81398437, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x81398437, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x81398437, 0x9503366, 0x89503420, 0x3000010}, +{0x3000000, 0x81398437, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x81398437, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x81398437, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x81398437, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0x81398437, 0x966320b, 0x896632c5, 0x3000010}, +{0x3000000, 0x81398437, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0x81398437, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0x81398437, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0x81398437, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0x81398437, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x81398437, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x0, 0x8ba98d27, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x1, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x76, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x2b94, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x636d24, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x7fffff, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x800000, 0x8ba98d29, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x800002, 0x8ba98d29, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x1398437, 0x8ba98d2d, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xba98d27, 0x8c298d27, 0x3000000}, +{0x3000000, 0x8ba98d27, 0xba98d7a, 0x8c298d50, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x80000000, 0x8ba98d27, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x80000001, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x80000076, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x80002b94, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x80636d24, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x807fffff, 0x8ba98d27, 0x3000080}, +{0x3000000, 0x8ba98d27, 0x80800000, 0x8ba98d25, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x80800002, 0x8ba98d25, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x81398437, 0x8ba98d21, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x8ba98d27, 0x0, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x8ba98d7a, 0x3260000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d27, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d27, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x9503366, 0x8bb00ec2, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x966320b, 0x8bb0beb7, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0x8ba98d27, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x8ba98d27, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x0, 0x8ba98d7a, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x1, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x76, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x2b94, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x636d24, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x7fffff, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x800000, 0x8ba98d7c, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x800002, 0x8ba98d7c, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x1398437, 0x8ba98d80, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xba98d27, 0x8c298d50, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xba98d7a, 0x8c298d7a, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x80000000, 0x8ba98d7a, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x80000001, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x80000076, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x80002b94, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x80636d24, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x807fffff, 0x8ba98d7a, 0x3000080}, +{0x3000000, 0x8ba98d7a, 0x80800000, 0x8ba98d78, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x80800002, 0x8ba98d78, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x81398437, 0x8ba98d74, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x8ba98d27, 0x83260000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x8ba98d7a, 0x0, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x8ba98d7a, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x8ba98d7a, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x9503366, 0x8bb00f15, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x966320b, 0x8bb0bf0a, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x8ba98d7a, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0xf51f853a, 0x0, 0xf51f853a, 0x3000000}, +{0x3000000, 0xf51f853a, 0x1, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x76, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x2b94, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x636d24, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x7fffff, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x800000, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x800002, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x1398437, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xba98d27, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xba98d7a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x751f853a, 0xf59f853a, 0x3000000}, +{0x3000000, 0xf51f853a, 0x7f7ffff0, 0xff7ffffa, 0x3000010}, +{0x3000000, 0xf51f853a, 0x7f7fffff, 0xff800000, 0x3000014}, +{0x3000000, 0xf51f853a, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xf51f853a, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0x80000000, 0xf51f853a, 0x3000000}, +{0x3000000, 0xf51f853a, 0x80000001, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x80000076, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x80002b94, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x80636d24, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x807fffff, 0xf51f853a, 0x3000080}, +{0x3000000, 0xf51f853a, 0x80800000, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x80800002, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x81398437, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x8ba98d27, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x8ba98d7a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xf51f853a, 0x0, 0x3000000}, +{0x3000000, 0xf51f853a, 0xff7ffff0, 0x7f7fffe6, 0x3000010}, +{0x3000000, 0xf51f853a, 0xff7fffff, 0x7f7ffff5, 0x3000010}, +{0x3000000, 0xf51f853a, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xf51f853a, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xf51f853a, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xf51f853a, 0x4f3495cb, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xe73a5134, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x7c994e9e, 0xfc994fdd, 0x3000010}, +{0x3000000, 0xf51f853a, 0x6164bd6c, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x9503366, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xbf5a97c9, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xe6ff1a14, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x77f31e2f, 0xf7f81a59, 0x3000010}, +{0x3000000, 0xf51f853a, 0xaab4d7d8, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x966320b, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xb26bddee, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0xb5c8e5d3, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x317285d3, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x3c9623b1, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x51fd2c7c, 0xf51f853a, 0x3000010}, +{0x3000000, 0xf51f853a, 0x7b906a6c, 0xfb906f68, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x0, 0xff7ffff0, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x1, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x76, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x2b94, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x636d24, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x7fffff, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x800000, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x800002, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x1398437, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xba98d27, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xba98d7a, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x751f853a, 0xff7ffffa, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x7f7ffff0, 0xff800000, 0x3000014}, +{0x3000000, 0xff7ffff0, 0x7f7fffff, 0xff800000, 0x3000014}, +{0x3000000, 0xff7ffff0, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x80000000, 0xff7ffff0, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x80000001, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x80000076, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x80002b94, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x80636d24, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x807fffff, 0xff7ffff0, 0x3000080}, +{0x3000000, 0xff7ffff0, 0x80800000, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x80800002, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x81398437, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x8ba98d27, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x8ba98d7a, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xf51f853a, 0xff7fffe6, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xff7ffff0, 0x0, 0x3000000}, +{0x3000000, 0xff7ffff0, 0xff7fffff, 0x75700000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7ffff0, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7ffff0, 0x4f3495cb, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xe73a5134, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x7c994e9e, 0xff800000, 0x3000014}, +{0x3000000, 0xff7ffff0, 0x6164bd6c, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x9503366, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xbf5a97c9, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xe6ff1a14, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x77f31e2f, 0xff800000, 0x3000014}, +{0x3000000, 0xff7ffff0, 0xaab4d7d8, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x966320b, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xb26bddee, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0xb5c8e5d3, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x317285d3, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x3c9623b1, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x51fd2c7c, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xff7ffff0, 0x7b906a6c, 0xff800000, 0x3000014}, +{0x3000000, 0xff7fffff, 0x0, 0xff7fffff, 0x3000000}, +{0x3000000, 0xff7fffff, 0x1, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x76, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x2b94, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x636d24, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x7fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x800000, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x800002, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x1398437, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xba98d27, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xba98d7a, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x751f853a, 0xff800000, 0x3000014}, +{0x3000000, 0xff7fffff, 0x7f7ffff0, 0xff800000, 0x3000014}, +{0x3000000, 0xff7fffff, 0x7f7fffff, 0xff800000, 0x3000014}, +{0x3000000, 0xff7fffff, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x80000000, 0xff7fffff, 0x3000000}, +{0x3000000, 0xff7fffff, 0x80000001, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x80000076, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x80002b94, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x80636d24, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x807fffff, 0xff7fffff, 0x3000080}, +{0x3000000, 0xff7fffff, 0x80800000, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x80800002, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x81398437, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x8ba98d27, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x8ba98d7a, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xf51f853a, 0xff7ffff5, 0x3000010}, +{0x3000000, 0xff7fffff, 0xff7ffff0, 0xf5700000, 0x3000000}, +{0x3000000, 0xff7fffff, 0xff7fffff, 0x0, 0x3000000}, +{0x3000000, 0xff7fffff, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xff7fffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff7fffff, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff7fffff, 0x4f3495cb, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xe73a5134, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x7c994e9e, 0xff800000, 0x3000014}, +{0x3000000, 0xff7fffff, 0x6164bd6c, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x9503366, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xbf5a97c9, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xe6ff1a14, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x77f31e2f, 0xff800000, 0x3000014}, +{0x3000000, 0xff7fffff, 0xaab4d7d8, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x966320b, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xb26bddee, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0xb5c8e5d3, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x317285d3, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x3c9623b1, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x51fd2c7c, 0xff7fffff, 0x3000010}, +{0x3000000, 0xff7fffff, 0x7b906a6c, 0xff800000, 0x3000014}, +{0x3000000, 0xff800000, 0x0, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x1, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x76, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x2b94, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x636d24, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x7fffff, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x800000, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x800002, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x1398437, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xba98d27, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xba98d7a, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x751f853a, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7f7ffff0, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7f7fffff, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0x80000000, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x80000001, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x80000076, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x80002b94, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x80636d24, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x807fffff, 0xff800000, 0x3000080}, +{0x3000000, 0xff800000, 0x80800000, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x80800002, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x81398437, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x8ba98d27, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x8ba98d7a, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xf51f853a, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xff7ffff0, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xff7fffff, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xff800000, 0x4f3495cb, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xe73a5134, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7c994e9e, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x6164bd6c, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x9503366, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xbf5a97c9, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xe6ff1a14, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x77f31e2f, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xaab4d7d8, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x966320b, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xb26bddee, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0xb5c8e5d3, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x317285d3, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x3c9623b1, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x51fd2c7c, 0xff800000, 0x3000000}, +{0x3000000, 0xff800000, 0x7b906a6c, 0xff800000, 0x3000000}, +{0x3000000, 0xff800001, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff800001, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff800001, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xff984a37, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xff984a37, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x1, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x76, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x2b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x7fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x1398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x751f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7f7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7f7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7f800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7fc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7fd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7fffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x80000000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x80000001, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x80000076, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x80002b94, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x80636d24, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x807fffff, 0x7fc00000, 0x3000081}, +{0x3000000, 0xffbfffff, 0x80800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x80800002, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x81398437, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x8ba98d27, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x8ba98d7a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xf51f853a, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xff7ffff0, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xff7fffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xff800000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xffc00000, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xffd9ba98, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xffffffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x4f3495cb, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xe73a5134, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7c994e9e, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x6164bd6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x9503366, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xbf5a97c9, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xe6ff1a14, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x77f31e2f, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xaab4d7d8, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x966320b, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xb26bddee, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0xb5c8e5d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x317285d3, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x3c9623b1, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x51fd2c7c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffbfffff, 0x7b906a6c, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffc00000, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffc00000, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffc00000, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffd9ba98, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffd9ba98, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffd9ba98, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x1, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x76, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x2b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x7fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x1398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x751f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7f7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7f7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7f800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x80000000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x80000001, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x80000076, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x80002b94, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x80636d24, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x807fffff, 0x7fc00000, 0x3000080}, +{0x3000000, 0xffffffff, 0x80800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x80800002, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x81398437, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x8ba98d27, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x8ba98d7a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xf51f853a, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xff7ffff0, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xff7fffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xff800000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xffffffff, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x4f3495cb, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xe73a5134, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7c994e9e, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x6164bd6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x9503366, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xbf5a97c9, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xe6ff1a14, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x77f31e2f, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xaab4d7d8, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x966320b, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xb26bddee, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0xb5c8e5d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x317285d3, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x3c9623b1, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x51fd2c7c, 0x7fc00000, 0x3000000}, +{0x3000000, 0xffffffff, 0x7b906a6c, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x0, 0x4f3495cb, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x1, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x76, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x2b94, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x636d24, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x7fffff, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x800000, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x800002, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x1398437, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xba98d27, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xba98d7a, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x80000000, 0x4f3495cb, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x80000001, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x80000076, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x80002b94, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x80636d24, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x807fffff, 0x4f3495cb, 0x3000080}, +{0x3000000, 0x4f3495cb, 0x80800000, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x80800002, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x81398437, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x8ba98d27, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x8ba98d7a, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x4f3495cb, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x4f3495cb, 0x4f3495cb, 0x0, 0x3000000}, +{0x3000000, 0x4f3495cb, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x9503366, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xbf5a97c9, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xaab4d7d8, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x966320b, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xb26bddee, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0xb5c8e5d3, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x317285d3, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x3c9623b1, 0x4f3495cb, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x51fd2c7c, 0xd1f787ce, 0x3000010}, +{0x3000000, 0x4f3495cb, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0xe73a5134, 0x0, 0xe73a5134, 0x3000000}, +{0x3000000, 0xe73a5134, 0x1, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x76, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x2b94, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x636d24, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x7fffff, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x800000, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x800002, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x1398437, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xba98d27, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xba98d7a, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xe73a5134, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xe73a5134, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xe73a5134, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xe73a5134, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0x80000000, 0xe73a5134, 0x3000000}, +{0x3000000, 0xe73a5134, 0x80000001, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x80000076, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x80002b94, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x80636d24, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x807fffff, 0xe73a5134, 0x3000080}, +{0x3000000, 0xe73a5134, 0x80800000, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x80800002, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x81398437, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x8ba98d27, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x8ba98d7a, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xe73a5134, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xe73a5134, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xe73a5134, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xe73a5134, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe73a5134, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe73a5134, 0x4f3495cb, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xe73a5134, 0x0, 0x3000000}, +{0x3000000, 0xe73a5134, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0xe73a5134, 0x6164bd6c, 0xe73a5f80, 0x3000010}, +{0x3000000, 0xe73a5134, 0x9503366, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xbf5a97c9, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xe6ff1a14, 0xe66b10a8, 0x3000000}, +{0x3000000, 0xe73a5134, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0xe73a5134, 0xaab4d7d8, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x966320b, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xb26bddee, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0xb5c8e5d3, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x317285d3, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x3c9623b1, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x51fd2c7c, 0xe73a5134, 0x3000010}, +{0x3000000, 0xe73a5134, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x0, 0x7c994e9e, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x1, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x76, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x2b94, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x636d24, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x7fffff, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x800000, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x800002, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x1398437, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xba98d27, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xba98d7a, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x751f853a, 0x7c994d5f, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x7f7ffff0, 0xff7b357b, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x7f7fffff, 0xff7b358a, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x80000000, 0x7c994e9e, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x80000001, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x80000076, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x80002b94, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x80636d24, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x807fffff, 0x7c994e9e, 0x3000080}, +{0x3000000, 0x7c994e9e, 0x80800000, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x80800002, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x81398437, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x8ba98d27, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x8ba98d7a, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xf51f853a, 0x7c994fdd, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xff7ffff0, 0x7f800000, 0x3000014}, +{0x3000000, 0x7c994e9e, 0xff7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x7c994e9e, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7c994e9e, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x4f3495cb, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xe73a5134, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x7c994e9e, 0x0, 0x3000000}, +{0x3000000, 0x7c994e9e, 0x6164bd6c, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x9503366, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xbf5a97c9, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xe6ff1a14, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x77f31e2f, 0x7c9911d6, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xaab4d7d8, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x966320b, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xb26bddee, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0xb5c8e5d3, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x317285d3, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x3c9623b1, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x51fd2c7c, 0x7c994e9e, 0x3000010}, +{0x3000000, 0x7c994e9e, 0x7b906a6c, 0x7c6a6806, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x0, 0x6164bd6c, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x1, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x76, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x2b94, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x636d24, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x7fffff, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x800000, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x800002, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x1398437, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xba98d27, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xba98d7a, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x80000000, 0x6164bd6c, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x80000001, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x80000076, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x80002b94, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x80636d24, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x807fffff, 0x6164bd6c, 0x3000080}, +{0x3000000, 0x6164bd6c, 0x80800000, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x80800002, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x81398437, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x8ba98d27, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x8ba98d7a, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x6164bd6c, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x4f3495cb, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xe73a5134, 0x673a5f80, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x6164bd6c, 0x0, 0x3000000}, +{0x3000000, 0x6164bd6c, 0x9503366, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xbf5a97c9, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xe6ff1a14, 0x66ff36ac, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xaab4d7d8, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x966320b, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xb26bddee, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0xb5c8e5d3, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x317285d3, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x3c9623b1, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x51fd2c7c, 0x6164bd6c, 0x3000010}, +{0x3000000, 0x6164bd6c, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x9503366, 0x0, 0x9503366, 0x3000000}, +{0x3000000, 0x9503366, 0x1, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x76, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x2b94, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x636d24, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x7fffff, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x800000, 0x9503326, 0x3000000}, +{0x3000000, 0x9503366, 0x800002, 0x9503326, 0x3000010}, +{0x3000000, 0x9503366, 0x1398437, 0x95032ac, 0x3000010}, +{0x3000000, 0x9503366, 0xba98d27, 0x8ba30b8c, 0x3000010}, +{0x3000000, 0x9503366, 0xba98d7a, 0x8ba30bdf, 0x3000010}, +{0x3000000, 0x9503366, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x9503366, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x9503366, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x9503366, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x9503366, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0x80000000, 0x9503366, 0x3000000}, +{0x3000000, 0x9503366, 0x80000001, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x80000076, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x80002b94, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x80636d24, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x807fffff, 0x9503366, 0x3000080}, +{0x3000000, 0x9503366, 0x80800000, 0x95033a6, 0x3000000}, +{0x3000000, 0x9503366, 0x80800002, 0x95033a6, 0x3000010}, +{0x3000000, 0x9503366, 0x81398437, 0x9503420, 0x3000010}, +{0x3000000, 0x9503366, 0x8ba98d27, 0xbb00ec2, 0x3000010}, +{0x3000000, 0x9503366, 0x8ba98d7a, 0xbb00f15, 0x3000010}, +{0x3000000, 0x9503366, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x9503366, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x9503366, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x9503366, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x9503366, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x9503366, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x9503366, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x9503366, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x9503366, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x9503366, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x9503366, 0x9503366, 0x0, 0x3000000}, +{0x3000000, 0x9503366, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x9503366, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x9503366, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x9503366, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0x9503366, 0x966320b, 0x87aff528, 0x3000000}, +{0x3000000, 0x9503366, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0x9503366, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0x9503366, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0x9503366, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0x9503366, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x9503366, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x0, 0xbf5a97c9, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x1, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x76, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x2b94, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x636d24, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x7fffff, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x800000, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x800002, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x1398437, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xba98d27, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xba98d7a, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x80000000, 0xbf5a97c9, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x80000001, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x80000076, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x80002b94, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x80636d24, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x807fffff, 0xbf5a97c9, 0x3000080}, +{0x3000000, 0xbf5a97c9, 0x80800000, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x80800002, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x81398437, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x8ba98d27, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x8ba98d7a, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xbf5a97c9, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x9503366, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xbf5a97c9, 0x0, 0x3000000}, +{0x3000000, 0xbf5a97c9, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xaab4d7d8, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x966320b, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xb26bddee, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0xb5c8e5d3, 0xbf5a97b0, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x317285d3, 0xbf5a97c9, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x3c9623b1, 0xbf5f48e7, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0xbf5a97c9, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x0, 0xe6ff1a14, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x1, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x76, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x2b94, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x636d24, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x7fffff, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x800000, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x800002, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x1398437, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xba98d27, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xba98d7a, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x80000000, 0xe6ff1a14, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x80000001, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x80000076, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x80002b94, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x80636d24, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x807fffff, 0xe6ff1a14, 0x3000080}, +{0x3000000, 0xe6ff1a14, 0x80800000, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x80800002, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x81398437, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x8ba98d27, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x8ba98d7a, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xe6ff1a14, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x4f3495cb, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xe73a5134, 0x666b10a8, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x6164bd6c, 0xe6ff36ac, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x9503366, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xbf5a97c9, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xe6ff1a14, 0x0, 0x3000000}, +{0x3000000, 0xe6ff1a14, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xaab4d7d8, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x966320b, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xb26bddee, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0xb5c8e5d3, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x317285d3, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x3c9623b1, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x51fd2c7c, 0xe6ff1a14, 0x3000010}, +{0x3000000, 0xe6ff1a14, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x0, 0x77f31e2f, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x1, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x76, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x2b94, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x636d24, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x7fffff, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x800000, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x800002, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x1398437, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xba98d27, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xba98d7a, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x751f853a, 0x77ee2205, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x7f7ffff0, 0xff7ffe0a, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x7f7fffff, 0xff7ffe19, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x80000000, 0x77f31e2f, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x80000001, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x80000076, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x80002b94, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x80636d24, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x807fffff, 0x77f31e2f, 0x3000080}, +{0x3000000, 0x77f31e2f, 0x80800000, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x80800002, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x81398437, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x8ba98d27, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x8ba98d7a, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xf51f853a, 0x77f81a59, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xff7ffff0, 0x7f800000, 0x3000014}, +{0x3000000, 0x77f31e2f, 0xff7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x77f31e2f, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x77f31e2f, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x77f31e2f, 0x4f3495cb, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xe73a5134, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x7c994e9e, 0xfc9911d6, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x6164bd6c, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x9503366, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xbf5a97c9, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xe6ff1a14, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x77f31e2f, 0x0, 0x3000000}, +{0x3000000, 0x77f31e2f, 0xaab4d7d8, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x966320b, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xb26bddee, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0xb5c8e5d3, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x317285d3, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x3c9623b1, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x51fd2c7c, 0x77f31e2f, 0x3000010}, +{0x3000000, 0x77f31e2f, 0x7b906a6c, 0xfb8f774e, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x0, 0xaab4d7d8, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x1, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x76, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x2b94, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x636d24, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x7fffff, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x800000, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x800002, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x1398437, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xba98d27, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xba98d7a, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x80000000, 0xaab4d7d8, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x80000001, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x80000076, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x80002b94, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x80636d24, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x807fffff, 0xaab4d7d8, 0x3000080}, +{0x3000000, 0xaab4d7d8, 0x80800000, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x80800002, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x81398437, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x8ba98d27, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x8ba98d7a, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xaab4d7d8, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x9503366, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xaab4d7d8, 0x0, 0x3000000}, +{0x3000000, 0xaab4d7d8, 0x966320b, 0xaab4d7d8, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xb26bddee, 0x326bdc84, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0xb5c8e5d3, 0x35c8e5d0, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x317285d3, 0xb1728b7a, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0xaab4d7d8, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x966320b, 0x0, 0x966320b, 0x3000000}, +{0x3000000, 0x966320b, 0x1, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x76, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x2b94, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x636d24, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x7fffff, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x800000, 0x96631cb, 0x3000000}, +{0x3000000, 0x966320b, 0x800002, 0x96631cb, 0x3000010}, +{0x3000000, 0x966320b, 0x1398437, 0x9663151, 0x3000010}, +{0x3000000, 0x966320b, 0xba98d27, 0x8ba25b97, 0x3000010}, +{0x3000000, 0x966320b, 0xba98d7a, 0x8ba25bea, 0x3000010}, +{0x3000000, 0x966320b, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x966320b, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x966320b, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x966320b, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x966320b, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0x80000000, 0x966320b, 0x3000000}, +{0x3000000, 0x966320b, 0x80000001, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x80000076, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x80002b94, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x80636d24, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x807fffff, 0x966320b, 0x3000080}, +{0x3000000, 0x966320b, 0x80800000, 0x966324b, 0x3000000}, +{0x3000000, 0x966320b, 0x80800002, 0x966324b, 0x3000010}, +{0x3000000, 0x966320b, 0x81398437, 0x96632c5, 0x3000010}, +{0x3000000, 0x966320b, 0x8ba98d27, 0xbb0beb7, 0x3000010}, +{0x3000000, 0x966320b, 0x8ba98d7a, 0xbb0bf0a, 0x3000010}, +{0x3000000, 0x966320b, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x966320b, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x966320b, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x966320b, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x966320b, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x966320b, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x966320b, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x966320b, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x966320b, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x966320b, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x966320b, 0x9503366, 0x7aff528, 0x3000000}, +{0x3000000, 0x966320b, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x966320b, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x966320b, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x966320b, 0xaab4d7d8, 0x2ab4d7d8, 0x3000010}, +{0x3000000, 0x966320b, 0x966320b, 0x0, 0x3000000}, +{0x3000000, 0x966320b, 0xb26bddee, 0x326bddee, 0x3000010}, +{0x3000000, 0x966320b, 0xb5c8e5d3, 0x35c8e5d3, 0x3000010}, +{0x3000000, 0x966320b, 0x317285d3, 0xb17285d3, 0x3000010}, +{0x3000000, 0x966320b, 0x3c9623b1, 0xbc9623b1, 0x3000010}, +{0x3000000, 0x966320b, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x966320b, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0xb26bddee, 0x0, 0xb26bddee, 0x3000000}, +{0x3000000, 0xb26bddee, 0x1, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x76, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x2b94, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x636d24, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x7fffff, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x800000, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x800002, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x1398437, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0xba98d27, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0xba98d7a, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xb26bddee, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xb26bddee, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xb26bddee, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xb26bddee, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0x80000000, 0xb26bddee, 0x3000000}, +{0x3000000, 0xb26bddee, 0x80000001, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x80000076, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x80002b94, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x80636d24, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x807fffff, 0xb26bddee, 0x3000080}, +{0x3000000, 0xb26bddee, 0x80800000, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x80800002, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x81398437, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x8ba98d27, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0x8ba98d7a, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xb26bddee, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xb26bddee, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xb26bddee, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xb26bddee, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb26bddee, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb26bddee, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0xb26bddee, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0xb26bddee, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0xb26bddee, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0xb26bddee, 0x9503366, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0xb26bddee, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0xb26bddee, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0xb26bddee, 0xaab4d7d8, 0xb26bdc84, 0x3000010}, +{0x3000000, 0xb26bddee, 0x966320b, 0xb26bddee, 0x3000010}, +{0x3000000, 0xb26bddee, 0xb26bddee, 0x0, 0x3000000}, +{0x3000000, 0xb26bddee, 0xb5c8e5d3, 0x35c70e17, 0x3000010}, +{0x3000000, 0xb26bddee, 0x317285d3, 0xb2943fb1, 0x3000010}, +{0x3000000, 0xb26bddee, 0x3c9623b1, 0xbc9623b8, 0x3000010}, +{0x3000000, 0xb26bddee, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0xb26bddee, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x0, 0xb5c8e5d3, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x1, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x76, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x2b94, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x636d24, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x7fffff, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x800000, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x800002, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x1398437, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xba98d27, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xba98d7a, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x80000000, 0xb5c8e5d3, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x80000001, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x80000076, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x80002b94, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x80636d24, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x807fffff, 0xb5c8e5d3, 0x3000080}, +{0x3000000, 0xb5c8e5d3, 0x80800000, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x80800002, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x81398437, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x8ba98d27, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x8ba98d7a, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0xb5c8e5d3, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x9503366, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xbf5a97c9, 0x3f5a97b0, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xaab4d7d8, 0xb5c8e5d0, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x966320b, 0xb5c8e5d3, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xb26bddee, 0xb5c70e17, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0xb5c8e5d3, 0x0, 0x3000000}, +{0x3000000, 0xb5c8e5d3, 0x317285d3, 0xb5c95f16, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x3c9623b1, 0xbc9626d5, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0xb5c8e5d3, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x317285d3, 0x0, 0x317285d3, 0x3000000}, +{0x3000000, 0x317285d3, 0x1, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x76, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x2b94, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x636d24, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x7fffff, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x800000, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x800002, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x1398437, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0xba98d27, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0xba98d7a, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x317285d3, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x317285d3, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x317285d3, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x317285d3, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0x80000000, 0x317285d3, 0x3000000}, +{0x3000000, 0x317285d3, 0x80000001, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x80000076, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x80002b94, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x80636d24, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x807fffff, 0x317285d3, 0x3000080}, +{0x3000000, 0x317285d3, 0x80800000, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x80800002, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x81398437, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x8ba98d27, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0x8ba98d7a, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x317285d3, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x317285d3, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x317285d3, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x317285d3, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x317285d3, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x317285d3, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x317285d3, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x317285d3, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x317285d3, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x317285d3, 0x9503366, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0xbf5a97c9, 0x3f5a97c9, 0x3000010}, +{0x3000000, 0x317285d3, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x317285d3, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x317285d3, 0xaab4d7d8, 0x31728b7a, 0x3000010}, +{0x3000000, 0x317285d3, 0x966320b, 0x317285d3, 0x3000010}, +{0x3000000, 0x317285d3, 0xb26bddee, 0x32943fb1, 0x3000010}, +{0x3000000, 0x317285d3, 0xb5c8e5d3, 0x35c95f16, 0x3000010}, +{0x3000000, 0x317285d3, 0x317285d3, 0x0, 0x3000000}, +{0x3000000, 0x317285d3, 0x3c9623b1, 0xbc9623af, 0x3000010}, +{0x3000000, 0x317285d3, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x317285d3, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x0, 0x3c9623b1, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x1, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x76, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x2b94, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x636d24, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x7fffff, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x800000, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x800002, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x1398437, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xba98d27, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xba98d7a, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x80000000, 0x3c9623b1, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x80000001, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x80000076, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x80002b94, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x80636d24, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x807fffff, 0x3c9623b1, 0x3000080}, +{0x3000000, 0x3c9623b1, 0x80800000, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x80800002, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x81398437, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x8ba98d27, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x8ba98d7a, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x3c9623b1, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x4f3495cb, 0xcf3495cb, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x9503366, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xbf5a97c9, 0x3f5f48e7, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xaab4d7d8, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x966320b, 0x3c9623b1, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xb26bddee, 0x3c9623b8, 0x3000010}, +{0x3000000, 0x3c9623b1, 0xb5c8e5d3, 0x3c9626d5, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x317285d3, 0x3c9623af, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x3c9623b1, 0x0, 0x3000000}, +{0x3000000, 0x3c9623b1, 0x51fd2c7c, 0xd1fd2c7c, 0x3000010}, +{0x3000000, 0x3c9623b1, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x0, 0x51fd2c7c, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x1, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x76, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x2b94, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x636d24, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x7fffff, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x800000, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x800002, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x1398437, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xba98d27, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xba98d7a, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x751f853a, 0xf51f853a, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x7f7ffff0, 0xff7ffff0, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x7f7fffff, 0xff7fffff, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x80000000, 0x51fd2c7c, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x80000001, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x80000076, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x80002b94, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x80636d24, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x807fffff, 0x51fd2c7c, 0x3000080}, +{0x3000000, 0x51fd2c7c, 0x80800000, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x80800002, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x81398437, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x8ba98d27, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x8ba98d7a, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xf51f853a, 0x751f853a, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xff7ffff0, 0x7f7ffff0, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xff7fffff, 0x7f7fffff, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x51fd2c7c, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x4f3495cb, 0x51f787ce, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xe73a5134, 0x673a5134, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x7c994e9e, 0xfc994e9e, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x6164bd6c, 0xe164bd6c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x9503366, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xbf5a97c9, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xe6ff1a14, 0x66ff1a14, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x77f31e2f, 0xf7f31e2f, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xaab4d7d8, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x966320b, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xb26bddee, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0xb5c8e5d3, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x317285d3, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x3c9623b1, 0x51fd2c7c, 0x3000010}, +{0x3000000, 0x51fd2c7c, 0x51fd2c7c, 0x0, 0x3000000}, +{0x3000000, 0x51fd2c7c, 0x7b906a6c, 0xfb906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x0, 0x7b906a6c, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x1, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x76, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x2b94, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x636d24, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x7fffff, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x800000, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x800002, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x1398437, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xba98d27, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xba98d7a, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x751f853a, 0x7b906570, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x7f7ffff0, 0xff7edf1b, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x7f7fffff, 0xff7edf2a, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x7f800000, 0xff800000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x7f800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0x7f984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0x7fbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0x7fc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x7fd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x7fffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x80000000, 0x7b906a6c, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x80000001, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x80000076, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x80002b94, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x80636d24, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x807fffff, 0x7b906a6c, 0x3000080}, +{0x3000000, 0x7b906a6c, 0x80800000, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x80800002, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x81398437, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x8ba98d27, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x8ba98d7a, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xf51f853a, 0x7b906f68, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xff7ffff0, 0x7f800000, 0x3000014}, +{0x3000000, 0x7b906a6c, 0xff7fffff, 0x7f800000, 0x3000014}, +{0x3000000, 0x7b906a6c, 0xff800000, 0x7f800000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0xff800001, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0xff984a37, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0xffbfffff, 0x7fc00000, 0x3000001}, +{0x3000000, 0x7b906a6c, 0xffc00000, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0xffd9ba98, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0xffffffff, 0x7fc00000, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x4f3495cb, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xe73a5134, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x7c994e9e, 0xfc6a6806, 0x3000000}, +{0x3000000, 0x7b906a6c, 0x6164bd6c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x9503366, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xbf5a97c9, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xe6ff1a14, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x77f31e2f, 0x7b8f774e, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xaab4d7d8, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x966320b, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xb26bddee, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0xb5c8e5d3, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x317285d3, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x3c9623b1, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x51fd2c7c, 0x7b906a6c, 0x3000010}, +{0x3000000, 0x7b906a6c, 0x7b906a6c, 0x0, 0x3000000}, diff --git a/externals/dynarmic/tests/A64/a64.cpp b/externals/dynarmic/tests/A64/a64.cpp new file mode 100644 index 0000000000..bf7125cbed --- /dev/null +++ b/externals/dynarmic/tests/A64/a64.cpp @@ -0,0 +1,1900 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <catch2/catch_test_macros.hpp> +#include <oaknut/oaknut.hpp> + +#include "./testenv.h" +#include "dynarmic/common/fp/fpsr.h" +#include "dynarmic/interface/exclusive_monitor.h" + +using namespace Dynarmic; +using namespace oaknut::util; + +TEST_CASE("A64: ADD", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x8b020020); // ADD X0, X1, X2 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetRegister(0, 0); + jit.SetRegister(1, 1); + jit.SetRegister(2, 2); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetRegister(0) == 3); + REQUIRE(jit.GetRegister(1) == 1); + REQUIRE(jit.GetRegister(2) == 2); + REQUIRE(jit.GetPC() == 4); +} + +TEST_CASE("A64: ADD{V,P}", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x0E31B801); // ADDV b1, v0.8b + env.code_mem.emplace_back(0x4E31B802); // ADDV b2, v0.16b + env.code_mem.emplace_back(0x0E71B803); // ADDV h3, v0.4h + env.code_mem.emplace_back(0x4E71B804); // ADDV h4, v0.8h + env.code_mem.emplace_back(0x0EA0BC05); // ADDP v5.2s, v0.2s, v0.2s + env.code_mem.emplace_back(0x4EB1B806); // ADDV s6, v0.4s + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetVector(0, {0x0101010101010101, 0x0101010101010101}); + jit.SetPC(0); + + env.ticks_left = 7; + jit.Run(); + + REQUIRE(jit.GetVector(1) == Vector{0x0000000000000008, 0x0000000000000000}); + REQUIRE(jit.GetVector(2) == Vector{0x0000000000000010, 0x0000000000000000}); + REQUIRE(jit.GetVector(3) == Vector{0x0000000000000404, 0x0000000000000000}); + REQUIRE(jit.GetVector(4) == Vector{0x0000000000000808, 0x0000000000000000}); + REQUIRE(jit.GetVector(5) == Vector{0x0202020202020202, 0x0000000000000000}); + REQUIRE(jit.GetVector(6) == Vector{0x0000000004040404, 0x0000000000000000}); +} + +TEST_CASE("A64: CLZ", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; + code.CLZ(V3.B16(), V0.B16()); + code.CLZ(V4.H8(), V1.H8()); + code.CLZ(V5.S4(), V2.S4()); + + jit.SetPC(0); + jit.SetVector(0, {0xeff0fafbfcfdfeff, 0xff7f3f1f0f070301}); + jit.SetVector(1, {0xfffcfffdfffeffff, 0x000F000700030001}); + jit.SetVector(2, {0xfffffffdfffffffe, 0x0000000300000001}); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + REQUIRE(jit.GetVector(3) == Vector{0x0, 0x0001020304050607}); + REQUIRE(jit.GetVector(4) == Vector{0x0, 0x000c000d000e000f}); + REQUIRE(jit.GetVector(5) == Vector{0x0, 0x0000001e0000001f}); +} + +TEST_CASE("A64: UADDL{V,P}", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x2E303801); // UADDLV h1, v0.8b + env.code_mem.emplace_back(0x6E303802); // UADDLV h2, v0.16b + env.code_mem.emplace_back(0x2E703803); // UADDLV s3, v0.4h + env.code_mem.emplace_back(0x6E703804); // UADDLV s4, v0.8h + env.code_mem.emplace_back(0x2EA02805); // UADDLP v5.1d, v0.2s + env.code_mem.emplace_back(0x6EB03806); // UADDLV d6, v0.4s + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetVector(0, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); + jit.SetPC(0); + + env.ticks_left = 7; + jit.Run(); + + REQUIRE(jit.GetVector(1) == Vector{0x00000000000007f8, 0x0000000000000000}); + REQUIRE(jit.GetVector(2) == Vector{0x0000000000000ff0, 0x0000000000000000}); + REQUIRE(jit.GetVector(3) == Vector{0x000000000003fffc, 0x0000000000000000}); + REQUIRE(jit.GetVector(4) == Vector{0x000000000007fff8, 0x0000000000000000}); + REQUIRE(jit.GetVector(5) == Vector{0x00000001fffffffe, 0x0000000000000000}); + REQUIRE(jit.GetVector(6) == Vector{0x00000003fffffffc, 0x0000000000000000}); +} + +TEST_CASE("A64: SADDL{V,P}", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x0E303801); // SADDLV h1, v0.8b + env.code_mem.emplace_back(0x4E303802); // SADDLV h2, v0.16b + env.code_mem.emplace_back(0x0E703803); // SADDLV s3, v0.4h + env.code_mem.emplace_back(0x4E703804); // SADDLV s4, v0.8h + env.code_mem.emplace_back(0x0EA02805); // SADDLP v5.1d, v0.2s + env.code_mem.emplace_back(0x4EB03806); // SADDLV d6, v0.4s + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetVector(0, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); + jit.SetPC(0); + + env.ticks_left = 7; + jit.Run(); + + REQUIRE(jit.GetVector(1) == Vector{0x000000000000fff8, 0x0000000000000000}); + REQUIRE(jit.GetVector(2) == Vector{0x000000000000fff0, 0x0000000000000000}); + REQUIRE(jit.GetVector(3) == Vector{0x00000000fffffffc, 0x0000000000000000}); + REQUIRE(jit.GetVector(4) == Vector{0x00000000fffffff8, 0x0000000000000000}); + REQUIRE(jit.GetVector(5) == Vector{0xfffffffffffffffe, 0x0000000000000000}); + REQUIRE(jit.GetVector(6) == Vector{0xfffffffffffffffc, 0x0000000000000000}); +} + +TEST_CASE("A64: VQADD", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x6e210c02); // UQADD v2.16b, v0.16b, v1.16b + env.code_mem.emplace_back(0x4e210c03); // SQADD v3.16b, v0.16b, v1.16b + env.code_mem.emplace_back(0x6e610c04); // UQADD v4.8h, v0.8h, v1.8h + env.code_mem.emplace_back(0x4e610c05); // SQADD v5.8h, v0.8h, v1.8h + env.code_mem.emplace_back(0x6ea10c06); // UQADD v6.4s, v0.4s, v1.4s + env.code_mem.emplace_back(0x4ea10c07); // SQADD v7.4s, v0.4s, v1.4s + env.code_mem.emplace_back(0x6ee10c08); // UQADD v8.2d, v0.2d, v1.2d + env.code_mem.emplace_back(0x4ee10c09); // SQADD v9.2d, v0.2d, v1.2d + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetVector(0, {0x7F7F7F7F7F7F7F7F, 0x7FFFFFFF7FFF7FFF}); + jit.SetVector(1, {0x8010FF00807F0000, 0x8000000080008000}); + jit.SetPC(0); + + env.ticks_left = 9; + jit.Run(); + + REQUIRE(jit.GetVector(2) == Vector{0xff8fff7ffffe7f7f, 0xffffffffffffffff}); + REQUIRE(jit.GetVector(3) == Vector{0xff7f7e7fff7f7f7f, 0xffffffffffffffff}); + REQUIRE(jit.GetVector(4) == Vector{0xff8ffffffffe7f7f, 0xffffffffffffffff}); + REQUIRE(jit.GetVector(5) == Vector{0xff8f7e7ffffe7f7f, 0xffffffffffffffff}); + REQUIRE(jit.GetVector(6) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff}); + REQUIRE(jit.GetVector(7) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff}); + REQUIRE(jit.GetVector(8) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff}); + REQUIRE(jit.GetVector(9) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff}); +} + +TEST_CASE("A64: VQSUB", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x6e212c02); // UQSUB v2.16b, v0.16b, v1.16b + env.code_mem.emplace_back(0x4e212c03); // SQSUB v3.16b, v0.16b, v1.16b + env.code_mem.emplace_back(0x6e612c04); // UQSUB v4.8h, v0.8h, v1.8h + env.code_mem.emplace_back(0x4e612c05); // SQSUB v5.8h, v0.8h, v1.8h + env.code_mem.emplace_back(0x6ea12c06); // UQSUB v6.4s, v0.4s, v1.4s + env.code_mem.emplace_back(0x4ea12c07); // SQSUB v7.4s, v0.4s, v1.4s + env.code_mem.emplace_back(0x6ee12c08); // UQSUB v8.2d, v0.2d, v1.2d + env.code_mem.emplace_back(0x4ee12c09); // SQSUB v9.2d, v0.2d, v1.2d + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetVector(0, {0x8010FF00807F0000, 0x8000000080008000}); + jit.SetVector(1, {0x7F7F7F7F7F7F7F7F, 0x7FFFFFFF7FFF7FFF}); + jit.SetPC(0); + + env.ticks_left = 9; + jit.Run(); + + REQUIRE(jit.GetVector(2) == Vector{0x0100800001000000, 0x0100000001000100}); + REQUIRE(jit.GetVector(3) == Vector{0x8091808180008181, 0x8001010180018001}); + REQUIRE(jit.GetVector(4) == Vector{0x00917f8101000000, 0x0001000000010001}); + REQUIRE(jit.GetVector(5) == Vector{0x8000800080008081, 0x8000000180008000}); + REQUIRE(jit.GetVector(6) == Vector{0x00917f8100ff8081, 0x0000000100010001}); + REQUIRE(jit.GetVector(7) == Vector{0x8000000080000000, 0x8000000080000000}); + REQUIRE(jit.GetVector(8) == Vector{0x00917f8100ff8081, 0x0000000100010001}); + REQUIRE(jit.GetVector(9) == Vector{0x8000000000000000, 0x8000000000000000}); +} + +TEST_CASE("A64: REV", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0xdac00c00); // REV X0, X0 + env.code_mem.emplace_back(0x5ac00821); // REV W1, W1 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetRegister(0, 0xaabbccddeeff1100); + jit.SetRegister(1, 0xaabbccdd); + jit.SetPC(0); + + env.ticks_left = 3; + jit.Run(); + + REQUIRE(jit.GetRegister(0) == 0x11ffeeddccbbaa); + REQUIRE(jit.GetRegister(1) == 0xddccbbaa); + REQUIRE(jit.GetPC() == 8); +} + +TEST_CASE("A64: REV32", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0xdac00800); // REV32 X0, X0 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetRegister(0, 0xaabbccddeeff1100); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 0xddccbbaa0011ffee); + REQUIRE(jit.GetPC() == 4); +} + +TEST_CASE("A64: REV16", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0xdac00400); // REV16 X0, X0 + env.code_mem.emplace_back(0x5ac00421); // REV16 W1, W1 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetRegister(0, 0xaabbccddeeff1100); + jit.SetRegister(1, 0xaabbccdd); + + jit.SetPC(0); + + env.ticks_left = 3; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 0xbbaaddccffee0011); + REQUIRE(jit.GetRegister(1) == 0xbbaaddcc); + REQUIRE(jit.GetPC() == 8); +} + +TEST_CASE("A64: SSHL", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4e204484); // SSHL v4.16b, v4.16b, v0.16b + env.code_mem.emplace_back(0x4e6144a5); // SSHL v5.8h, v5.8h, v1.8h + env.code_mem.emplace_back(0x4ea244c6); // SSHL v6.4s, v6.4s, v2.4s + env.code_mem.emplace_back(0x4ee344e7); // SSHL v7.2d, v7.2d, v3.2d + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(0, {0xEFF0FAFBFCFDFEFF, 0x0807050403020100}); + jit.SetVector(1, {0xFFFCFFFDFFFEFFFF, 0x0004000300020001}); + jit.SetVector(2, {0xFFFFFFFDFFFFFFFE, 0x0000000200000001}); + jit.SetVector(3, {0xFFFFFFFFFFFFFFFF, 0x0000000000000001}); + + jit.SetVector(4, {0x8080808080808080, 0xFFFFFFFFFFFFFFFF}); + jit.SetVector(5, {0x8000800080008000, 0xFFFFFFFFFFFFFFFF}); + jit.SetVector(6, {0x8000000080000000, 0xFFFFFFFFFFFFFFFF}); + jit.SetVector(7, {0x8000000000000000, 0xFFFFFFFFFFFFFFFF}); + + env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.GetVector(4) == Vector{0xfffffefcf8f0e0c0, 0x0080e0f0f8fcfeff}); + REQUIRE(jit.GetVector(5) == Vector{0xf800f000e000c000, 0xfff0fff8fffcfffe}); + REQUIRE(jit.GetVector(6) == Vector{0xf0000000e0000000, 0xfffffffcfffffffe}); + REQUIRE(jit.GetVector(7) == Vector{0xc000000000000000, 0xfffffffffffffffe}); +} + +TEST_CASE("A64: USHL", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x6e204484); // USHL v4.16b, v4.16b, v0.16b + env.code_mem.emplace_back(0x6e6144a5); // USHL v5.8h, v5.8h, v1.8h + env.code_mem.emplace_back(0x6ea244c6); // USHL v6.4s, v6.4s, v2.4s + env.code_mem.emplace_back(0x6ee344e7); // USHL v7.2d, v7.2d, v3.2d + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(0, {0x10FE0E0D0C0B0A09, 0x0807050403020100}); + jit.SetVector(1, {0xFFFE000700060005, 0x0004000300020001}); + jit.SetVector(2, {0xFFFFFFFE00000003, 0x0000000200000001}); + jit.SetVector(3, {0xFFFFFFFFFFFFFFFE, 0x0000000000000001}); + + jit.SetVector(4, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); + jit.SetVector(5, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); + jit.SetVector(6, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); + jit.SetVector(7, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); + + env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.GetVector(4) == Vector{0x003f000000000000, 0x0080e0f0f8fcfeff}); + REQUIRE(jit.GetVector(5) == Vector{0x3fffff80ffc0ffe0, 0xfff0fff8fffcfffe}); + REQUIRE(jit.GetVector(6) == Vector{0x3ffffffffffffff8, 0xfffffffcfffffffe}); + REQUIRE(jit.GetVector(7) == Vector{0x3fffffffffffffff, 0xfffffffffffffffe}); +} + +TEST_CASE("A64: XTN", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x0e212803); // XTN v3.8b, v0.8h + env.code_mem.emplace_back(0x0e612824); // XTN v4.4h, v1.4s + env.code_mem.emplace_back(0x0ea12845); // XTN v5.2s, v2.2d + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(0, {0x3333222211110000, 0x7777666655554444}); + jit.SetVector(1, {0x1111111100000000, 0x3333333322222222}); + jit.SetVector(2, {0x0000000000000000, 0x1111111111111111}); + + env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.GetVector(3) == Vector{0x7766554433221100, 0x0000000000000000}); + REQUIRE(jit.GetVector(4) == Vector{0x3333222211110000, 0x0000000000000000}); + REQUIRE(jit.GetVector(5) == Vector{0x1111111100000000, 0x0000000000000000}); +} + +TEST_CASE("A64: TBL", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x0e000100); // TBL v0.8b, { v8.16b }, v0.8b + env.code_mem.emplace_back(0x4e010101); // TBL v1.16b, { v8.16b }, v1.16b + env.code_mem.emplace_back(0x0e022102); // TBL v2.8b, { v8.16b, v9.16b }, v2.8b + env.code_mem.emplace_back(0x4e032103); // TBL v3.16b, { v8.16b, v9.16b }, v3.16b + env.code_mem.emplace_back(0x0e044104); // TBL v4.8b, { v8.16b, v9.16b, v10.16b }, v4.8b + env.code_mem.emplace_back(0x4e054105); // TBL v5.16b, { v8.16b, v9.16b, v10.16b }, v5.16b + env.code_mem.emplace_back(0x0e066106); // TBL v6.8b, { v8.16b, v9.16b, v10.16b, v11.16b }, v6.8b + env.code_mem.emplace_back(0x4e076107); // TBL v7.16b, { v8.16b, v9.16b, v10.16b, v11.16b }, v7.16b + env.code_mem.emplace_back(0x14000000); // B . + + // Indices + // 'FF' intended to test out-of-index + jit.SetVector(0, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f}); + jit.SetVector(1, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f}); + jit.SetVector(2, {0x100011011202'FF'03, 0x1404150516061707}); + jit.SetVector(3, {0x100011011202'FF'03, 0x1404150516061707}); + jit.SetVector(4, {0x201000211101'FF'12, 0x0233231303241404}); + jit.SetVector(5, {0x201000211101'FF'12, 0x0233231303241404}); + jit.SetVector(6, {0x403010004131'FF'01, 0x4232120243332303}); + jit.SetVector(7, {0x403010004131'FF'01, 0x4232120243332303}); + + // Table + jit.SetVector(8, {0x7766554433221100, 0xffeeddccbbaa9988}); + jit.SetVector(9, {0xffffffffffffffff, 0xffffffffffffffff}); + jit.SetVector(10, {0xeeeeeeeeeeeeeeee, 0xeeeeeeeeeeeeeeee}); + jit.SetVector(11, {0xdddddddddddddddd, 0xdddddddddddddddd}); + + jit.SetPC(0); + + env.ticks_left = 9; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0x001122334455'00'77, 0x0000000000000000}); + REQUIRE(jit.GetVector(1) == Vector{0x001122334455'00'77, 0x8899aabbccddeeff}); + REQUIRE(jit.GetVector(2) == Vector{0xff00ff11ff22'00'33, 0x0000000000000000}); + REQUIRE(jit.GetVector(3) == Vector{0xff00ff11ff22'00'33, 0xff44ff55ff66ff77}); + REQUIRE(jit.GetVector(4) == Vector{0xeeff00eeff11'00'ff, 0x0000000000000000}); + REQUIRE(jit.GetVector(5) == Vector{0xeeff00eeff11'00'ff, 0x2200eeff33eeff44}); + REQUIRE(jit.GetVector(6) == Vector{0x00ddff0000dd'00'11, 0x0000000000000000}); + REQUIRE(jit.GetVector(7) == Vector{0x00ddff0000dd'00'11, 0x00ddff2200ddee33}); +} + +TEST_CASE("A64: TBX", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x0e001100); // TBX v0.8b, { v8.16b }, v0.8b + env.code_mem.emplace_back(0x4e011101); // TBX v1.16b, { v8.16b }, v1.16b + env.code_mem.emplace_back(0x0e023102); // TBX v2.8b, { v8.16b, v9.16b }, v2.8b + env.code_mem.emplace_back(0x4e033103); // TBX v3.16b, { v8.16b, v9.16b }, v3.16b + env.code_mem.emplace_back(0x0e045104); // TBX v4.8b, { v8.16b, v9.16b, v10.16b }, v4.8b + env.code_mem.emplace_back(0x4e055105); // TBX v5.16b, { v8.16b, v9.16b, v10.16b }, v5.16b + env.code_mem.emplace_back(0x0e067106); // TBX v6.8b, { v8.16b, v9.16b, v10.16b, v11.16b }, v6.8b + env.code_mem.emplace_back(0x4e077107); // TBX v7.16b, { v8.16b, v9.16b, v10.16b, v11.16b }, v7.16b + env.code_mem.emplace_back(0x14000000); // B . + + // Indices + // 'FF' intended to test out-of-index + jit.SetVector(0, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f}); + jit.SetVector(1, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f}); + jit.SetVector(2, {0x100011011202'FF'03, 0x1404150516061707}); + jit.SetVector(3, {0x100011011202'FF'03, 0x1404150516061707}); + jit.SetVector(4, {0x201000211101'FF'12, 0x0233231303241404}); + jit.SetVector(5, {0x201000211101'FF'12, 0x0233231303241404}); + jit.SetVector(6, {0x403010004131'FF'01, 0x4232120243332303}); + jit.SetVector(7, {0x403010004131'FF'01, 0x4232120243332303}); + + // Table + jit.SetVector(8, {0x7766554433221100, 0xffeeddccbbaa9988}); + jit.SetVector(9, {0xffffffffffffffff, 0xffffffffffffffff}); + jit.SetVector(10, {0xeeeeeeeeeeeeeeee, 0xeeeeeeeeeeeeeeee}); + jit.SetVector(11, {0xdddddddddddddddd, 0xdddddddddddddddd}); + + jit.SetPC(0); + + env.ticks_left = 9; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0x001122334455'FF'77, 0x0000000000000000}); + REQUIRE(jit.GetVector(1) == Vector{0x001122334455'FF'77, 0x8899aabbccddeeff}); + REQUIRE(jit.GetVector(2) == Vector{0xff00ff11ff22'FF'33, 0x0000000000000000}); + REQUIRE(jit.GetVector(3) == Vector{0xff00ff11ff22'FF'33, 0xff44ff55ff66ff77}); + REQUIRE(jit.GetVector(4) == Vector{0xeeff00eeff11'FF'ff, 0x0000000000000000}); + REQUIRE(jit.GetVector(5) == Vector{0xeeff00eeff11'FF'ff, 0x2233eeff33eeff44}); + REQUIRE(jit.GetVector(6) == Vector{0x40ddff0041dd'FF'11, 0x0000000000000000}); + REQUIRE(jit.GetVector(7) == Vector{0x40ddff0041dd'FF'11, 0x42ddff2243ddee33}); +} + +TEST_CASE("A64: AND", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x8a020020); // AND X0, X1, X2 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetRegister(0, 0); + jit.SetRegister(1, 1); + jit.SetRegister(2, 3); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetRegister(0) == 1); + REQUIRE(jit.GetRegister(1) == 1); + REQUIRE(jit.GetRegister(2) == 3); + REQUIRE(jit.GetPC() == 4); +} + +TEST_CASE("A64: Bitmasks", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x3200c3e0); // ORR W0, WZR, #0x01010101 + env.code_mem.emplace_back(0x320c8fe1); // ORR W1, WZR, #0x00F000F0 + env.code_mem.emplace_back(0x320003e2); // ORR W2, WZR, #1 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + + env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.GetRegister(0) == 0x01010101); + REQUIRE(jit.GetRegister(1) == 0x00F000F0); + REQUIRE(jit.GetRegister(2) == 1); + REQUIRE(jit.GetPC() == 12); +} + +TEST_CASE("A64: ANDS NZCV", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x6a020020); // ANDS W0, W1, W2 + env.code_mem.emplace_back(0x14000000); // B . + + SECTION("N=1, Z=0") { + jit.SetRegister(0, 0); + jit.SetRegister(1, 0xFFFFFFFF); + jit.SetRegister(2, 0xFFFFFFFF); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetRegister(0) == 0xFFFFFFFF); + REQUIRE(jit.GetRegister(1) == 0xFFFFFFFF); + REQUIRE(jit.GetRegister(2) == 0xFFFFFFFF); + REQUIRE(jit.GetPC() == 4); + REQUIRE((jit.GetPstate() & 0xF0000000) == 0x80000000); + } + + SECTION("N=0, Z=1") { + jit.SetRegister(0, 0); + jit.SetRegister(1, 0xFFFFFFFF); + jit.SetRegister(2, 0x00000000); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetRegister(0) == 0x00000000); + REQUIRE(jit.GetRegister(1) == 0xFFFFFFFF); + REQUIRE(jit.GetRegister(2) == 0x00000000); + REQUIRE(jit.GetPC() == 4); + REQUIRE((jit.GetPstate() & 0xF0000000) == 0x40000000); + } + SECTION("N=0, Z=0") { + jit.SetRegister(0, 0); + jit.SetRegister(1, 0x12345678); + jit.SetRegister(2, 0x7324a993); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetRegister(0) == 0x12240010); + REQUIRE(jit.GetRegister(1) == 0x12345678); + REQUIRE(jit.GetRegister(2) == 0x7324a993); + REQUIRE(jit.GetPC() == 4); + REQUIRE((jit.GetPstate() & 0xF0000000) == 0x00000000); + } +} + +TEST_CASE("A64: CBZ", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x34000060); // 0x00 : CBZ X0, label + env.code_mem.emplace_back(0x320003e2); // 0x04 : MOV X2, 1 + env.code_mem.emplace_back(0x14000000); // 0x08 : B. + env.code_mem.emplace_back(0x321f03e2); // 0x0C : label: MOV X2, 2 + env.code_mem.emplace_back(0x14000000); // 0x10 : B . + + SECTION("no branch") { + jit.SetPC(0); + jit.SetRegister(0, 1); + + env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.GetRegister(2) == 1); + REQUIRE(jit.GetPC() == 8); + } + + SECTION("branch") { + jit.SetPC(0); + jit.SetRegister(0, 0); + + env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.GetRegister(2) == 2); + REQUIRE(jit.GetPC() == 16); + } +} + +TEST_CASE("A64: TBZ", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x36180060); // 0x00 : TBZ X0, 3, label + env.code_mem.emplace_back(0x320003e2); // 0x04 : MOV X2, 1 + env.code_mem.emplace_back(0x14000000); // 0x08 : B . + env.code_mem.emplace_back(0x321f03e2); // 0x0C : label: MOV X2, 2 + env.code_mem.emplace_back(0x14000000); // 0x10 : B . + + SECTION("no branch") { + jit.SetPC(0); + jit.SetRegister(0, 0xFF); + + env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.GetRegister(2) == 1); + REQUIRE(jit.GetPC() == 8); + } + + SECTION("branch with zero") { + jit.SetPC(0); + jit.SetRegister(0, 0); + + env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.GetRegister(2) == 2); + REQUIRE(jit.GetPC() == 16); + } + + SECTION("branch with non-zero") { + jit.SetPC(0); + jit.SetRegister(0, 1); + + env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.GetRegister(2) == 2); + REQUIRE(jit.GetPC() == 16); + } +} + +TEST_CASE("A64: FABD", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x6eb5d556); // FABD.4S V22, V10, V21 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(10, {0xb4858ac77ff39a87, 0x9fce5e14c4873176}); + jit.SetVector(21, {0x56d3f085ff890e2b, 0x6e4b0a41801a2d00}); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(22) == Vector{0x56d3f0857fc90e2b, 0x6e4b0a4144873176}); +} + +TEST_CASE("A64: FABS", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4ef8f804); // FABS v4.8h, v0.8h + env.code_mem.emplace_back(0x4ea0f825); // FABS v5.4s, v1.4s + env.code_mem.emplace_back(0x4ee0f846); // FABS v6.2d, v2.2d + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(0, {0xffffffffffffffff, 0xffffffffffff8000}); + jit.SetVector(1, {0xffbfffffffc00000, 0xff80000080000000}); + jit.SetVector(2, {0xffffffffffffffff, 0x8000000000000000}); + + env.ticks_left = 4; + jit.Run(); + + REQUIRE(jit.GetVector(4) == Vector{0x7fff7fff7fff7fff, 0x7fff7fff7fff0000}); + REQUIRE(jit.GetVector(5) == Vector{0x7fbfffff7fc00000, 0x7f80000000000000}); + REQUIRE(jit.GetVector(6) == Vector{0x7fffffffffffffff, 0x0000000000000000}); +} + +TEST_CASE("A64: FMIN (example)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4ea1f400); // FMIN.4S V0, V0, V1 + env.code_mem.emplace_back(0x4ee3f442); // FMIN.2D V2, V2, V3 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37}); + jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff}); + + jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000}); + jit.SetVector(3, {0xbff0000000000000, 0x6e4b0a41ffffffff}); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0x7fc00000'00000001, 0x00000000'7fd84a37}); + REQUIRE(jit.GetVector(2) == Vector{0xbff0000000000000, 0x3ff0000000000000}); +} + +TEST_CASE("A64: FMAX (example)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4e21f400); // FMAX.4S V0, V0, V1 + env.code_mem.emplace_back(0x4e63f442); // FMAX.2D V2, V2, V3 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37}); + jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff}); + + jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000}); + jit.SetVector(3, {0xbff0000000000000, 0x6e4b0a41ffffffff}); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0x7fc00000'09503366, 0x6e4b0a41'7fd84a37}); + REQUIRE(jit.GetVector(2) == Vector{0x7fc0000009503366, 0x6e4b0a41ffffffff}); +} + +TEST_CASE("A64: FMINNM (example)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4ea1c400); // FMINNM.4S V0, V0, V1 + env.code_mem.emplace_back(0x4ee3c442); // FMINNM.2D V2, V2, V3 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37}); + jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff}); + + jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000}); + jit.SetVector(3, {0xfff0000000000000, 0xffffffffffffffff}); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0xc1200000'00000001, 0x00000000'7fd84a37}); + REQUIRE(jit.GetVector(2) == Vector{0xfff0000000000000, 0x3ff0000000000000}); +} + +TEST_CASE("A64: FMAXNM (example)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4e21c400); // FMAXNM.4S V0, V0, V1 + env.code_mem.emplace_back(0x4e63c442); // FMAXNM.2D V2, V2, V3 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37}); + jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff}); + + jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000}); + jit.SetVector(3, {0xfff0000000000000, 0xffffffffffffffff}); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0xc1200000'09503366, 0x6e4b0a41'7fd84a37}); + REQUIRE(jit.GetVector(2) == Vector{0x7fc0000009503366, 0x3ff0000000000000}); +} + +TEST_CASE("A64: FMAXNM (example 2)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4e3bc6fd); // FMAXNM.4S V29, V23, V27 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetFpcr(0x01400000); + jit.SetVector(23, {0xb485877c'42280000, 0x317285d3'b5c8e5d3}); + jit.SetVector(27, {0xbc48d091'c79b271e, 0xff800001'3304c3ef}); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(29) == Vector{0xb485877c'42280000, 0xffc00001'3304c3ef}); +} + +TEST_CASE("A64: 128-bit exclusive read/write", "[a64]") { + A64TestEnv env; + ExclusiveMonitor monitor{1}; + + A64::UserConfig conf; + conf.callbacks = &env; + conf.processor_id = 0; + + SECTION("Global Monitor") { + conf.global_monitor = &monitor; + } + + A64::Jit jit{conf}; + + env.code_mem.emplace_back(0xc87f0861); // LDXP X1, X2, [X3] + env.code_mem.emplace_back(0xc8241865); // STXP W4, X5, X6, [X3] + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetRegister(3, 0x1234567812345678); + jit.SetRegister(4, 0xbaadbaadbaadbaad); + jit.SetRegister(5, 0xaf00d1e5badcafe0); + jit.SetRegister(6, 0xd0d0cacad0d0caca); + + env.ticks_left = 3; + jit.Run(); + + REQUIRE(jit.GetRegister(1) == 0x7f7e7d7c7b7a7978); + REQUIRE(jit.GetRegister(2) == 0x8786858483828180); + REQUIRE(jit.GetRegister(4) == 0); + REQUIRE(env.MemoryRead64(0x1234567812345678) == 0xaf00d1e5badcafe0); + REQUIRE(env.MemoryRead64(0x1234567812345680) == 0xd0d0cacad0d0caca); +} + +TEST_CASE("A64: CNTPCT_EL0", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0xd53be021); // MRS X1, CNTPCT_EL0 + env.code_mem.emplace_back(0xd503201f); // NOP + env.code_mem.emplace_back(0xd503201f); // NOP + env.code_mem.emplace_back(0xd503201f); // NOP + env.code_mem.emplace_back(0xd503201f); // NOP + env.code_mem.emplace_back(0xd503201f); // NOP + env.code_mem.emplace_back(0xd503201f); // NOP + env.code_mem.emplace_back(0xd53be022); // MRS X2, CNTPCT_EL0 + env.code_mem.emplace_back(0xcb010043); // SUB X3, X2, X1 + env.code_mem.emplace_back(0x14000000); // B . + + env.ticks_left = 10; + jit.Run(); + + REQUIRE(jit.GetRegister(3) == 7); +} + +TEST_CASE("A64: FNMSUB 1", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x1f618a9c); // FNMSUB D28, D20, D1, D2 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(20, {0xe73a51346164bd6c, 0x8080000000002b94}); + jit.SetVector(1, {0xbf8000007fffffff, 0xffffffff00002b94}); + jit.SetVector(2, {0x0000000000000000, 0xc79b271e3f000000}); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(28) == Vector{0x66ca513533ee6076, 0x0000000000000000}); +} + +TEST_CASE("A64: FNMSUB 2", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x1f2ab88e); // FNMSUB S14, S4, S10, S14 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(4, {0x3c9623b101398437, 0x7ff0abcd0ba98d27}); + jit.SetVector(10, {0xffbfffff3eaaaaab, 0x3f0000003f8147ae}); + jit.SetVector(14, {0x80000000007fffff, 0xe73a513400000000}); + jit.SetFpcr(0x00400000); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(14) == Vector{0x0000000080045284, 0x0000000000000000}); +} + +TEST_CASE("A64: FMADD", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x1f5e0e4a); // FMADD D10, D18, D30, D3 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(18, {0x8000007600800000, 0x7ff812347f800000}); + jit.SetVector(30, {0xff984a3700000000, 0xe73a513480800000}); + jit.SetVector(3, {0x3f000000ff7fffff, 0x8139843780000000}); + jit.SetFpcr(0x00400000); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(10) == Vector{0x3f059921bf0dbfff, 0x0000000000000000}); +} + +TEST_CASE("A64: FMLA.4S(lane)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4f8f11c0); // FMLA.4S V0, V14, V15[0] + env.code_mem.emplace_back(0x4faf11c1); // FMLA.4S V1, V14, V15[1] + env.code_mem.emplace_back(0x4f8f19c2); // FMLA.4S V2, V14, V15[2] + env.code_mem.emplace_back(0x4faf19c3); // FMLA.4S V3, V14, V15[3] + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(0, {0x3ff00000'3ff00000, 0x00000000'00000000}); + jit.SetVector(1, {0x3ff00000'3ff00000, 0x00000000'00000000}); + jit.SetVector(2, {0x3ff00000'3ff00000, 0x00000000'00000000}); + jit.SetVector(3, {0x3ff00000'3ff00000, 0x00000000'00000000}); + + jit.SetVector(14, {0x3ff00000'3ff00000, 0x3ff00000'3ff00000}); + jit.SetVector(15, {0x3ff00000'40000000, 0x40400000'40800000}); + + env.ticks_left = 5; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0x40b4000040b40000, 0x4070000040700000}); + REQUIRE(jit.GetVector(1) == Vector{0x40ac800040ac8000, 0x4061000040610000}); + REQUIRE(jit.GetVector(2) == Vector{0x4116000041160000, 0x40f0000040f00000}); + REQUIRE(jit.GetVector(3) == Vector{0x40f0000040f00000, 0x40b4000040b40000}); +} + +TEST_CASE("A64: FMUL.4S(lane)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4f8f91c0); // FMUL.4S V0, V14, V15[0] + env.code_mem.emplace_back(0x4faf91c1); // FMUL.4S V1, V14, V15[1] + env.code_mem.emplace_back(0x4f8f99c2); // FMUL.4S V2, V14, V15[2] + env.code_mem.emplace_back(0x4faf99c3); // FMUL.4S V3, V14, V15[3] + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(14, {0x3ff00000'3ff00000, 0x3ff00000'3ff00000}); + jit.SetVector(15, {0x3ff00000'40000000, 0x40400000'40800000}); + + env.ticks_left = 5; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0x4070000040700000, 0x4070000040700000}); + REQUIRE(jit.GetVector(1) == Vector{0x4061000040610000, 0x4061000040610000}); + REQUIRE(jit.GetVector(2) == Vector{0x40f0000040f00000, 0x40f0000040f00000}); + REQUIRE(jit.GetVector(3) == Vector{0x40b4000040b40000, 0x40b4000040b40000}); +} + +TEST_CASE("A64: FMLA.4S (denormal)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4e2fcccc); // FMLA.4S V12, V6, V15 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(12, {0x3c9623b17ff80000, 0xbff0000080000076}); + jit.SetVector(6, {0x7ff80000ff800000, 0x09503366c1200000}); + jit.SetVector(15, {0x3ff0000080636d24, 0xbf800000e73a5134}); + jit.SetFpcr(0x01000000); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(12) == Vector{0x7ff800007fc00000, 0xbff0000068e8e581}); +} + +TEST_CASE("A64: FMLA.4S (0x80800000)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4e38cc2b); // FMLA.4S V11, V1, V24 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(11, {0xc79b271efff05678, 0xffc0000080800000}); + jit.SetVector(1, {0x00636d2400800000, 0x0966320bb26bddee}); + jit.SetVector(24, {0x460e8c84fff00000, 0x8ba98d2780800002}); + jit.SetFpcr(0x03000000); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(11) == Vector{0xc79b271e7fc00000, 0x7fc0000080000000}); +} + +// x64 has different rounding behaviour to AArch64. +// AArch64 performs rounding after flushing-to-zero. +// x64 performs rounding before flushing-to-zero. +TEST_CASE("A64: FMADD (0x80800000)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x1f0f7319); // FMADD S25, S24, S15, S28 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(24, {0x00800000, 0}); + jit.SetVector(15, {0x0ba98d27, 0}); + jit.SetVector(28, {0x80800000, 0}); + jit.SetFpcr(0x01000000); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(25) == Vector{0x80000000, 0}); +} + +TEST_CASE("A64: FNEG failed to zero upper", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x2ea0fb50); // FNEG.2S V16, V26 + env.code_mem.emplace_back(0x2e207a1c); // SQNEG.8B V28, V16 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(26, {0x071286fde8f34a90, 0x837cffa8be382f60}); + jit.SetFpcr(0x01000000); + + env.ticks_left = 6; + jit.Run(); + + REQUIRE(jit.GetVector(28) == Vector{0x79ee7a03980db670, 0}); + REQUIRE(FP::FPSR{jit.GetFpsr()}.QC() == false); +} + +TEST_CASE("A64: FRSQRTS", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x5eb8fcad); // FRSQRTS S13, S5, S24 + env.code_mem.emplace_back(0x14000000); // B . + + // These particular values result in an intermediate value during + // the calculation that is close to infinity. We want to verify + // that this special case is handled appropriately. + + jit.SetPC(0); + jit.SetVector(5, {0xfc6a0206, 0}); + jit.SetVector(24, {0xfc6a0206, 0}); + jit.SetFpcr(0x00400000); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(13) == Vector{0xff7fffff, 0}); +} + +TEST_CASE("A64: SQDMULH.8H (saturate)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4e62b420); // SQDMULH.8H V0, V1, V2 + env.code_mem.emplace_back(0x14000000); // B . + + // Make sure that saturating values are tested + + jit.SetPC(0); + jit.SetVector(1, {0x7fff80007ffe8001, 0x7fff80007ffe8001}); + jit.SetVector(2, {0x7fff80007ffe8001, 0x80007fff80017ffe}); + jit.SetFpsr(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0x7ffe7fff7ffc7ffe, 0x8001800180028002}); + REQUIRE(FP::FPSR{jit.GetFpsr()}.QC() == true); +} + +TEST_CASE("A64: SQDMULH.4S (saturate)", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x4ea2b420); // SQDMULH.4S V0, V1, V2 + env.code_mem.emplace_back(0x14000000); // B . + + // Make sure that saturating values are tested + + jit.SetPC(0); + jit.SetVector(1, {0x7fffffff80000000, 0x7fffffff80000000}); + jit.SetVector(2, {0x7fffffff80000000, 0x800000007fffffff}); + jit.SetFpsr(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0x7ffffffe7fffffff, 0x8000000180000001}); + REQUIRE(FP::FPSR{jit.GetFpsr()}.QC() == true); +} + +TEST_CASE("A64: This is an infinite loop if fast dispatch is enabled", "[a64]") { + A64TestEnv env; + A64::UserConfig conf{&env}; + conf.optimizations &= ~OptimizationFlag::FastDispatch; + A64::Jit jit{conf}; + + env.code_mem.emplace_back(0x2ef998fa); + env.code_mem.emplace_back(0x2ef41c11); + env.code_mem.emplace_back(0x0f07fdd8); + env.code_mem.emplace_back(0x9ac90d09); + env.code_mem.emplace_back(0xd63f0120); // BLR X9 + env.code_mem.emplace_back(0x14000000); // B . + + env.ticks_left = 6; + jit.Run(); +} + +TEST_CASE("A64: EXTR", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x93d8fef7); // EXTR X23, X23, X24, #63 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetRegister(23, 0); + jit.SetRegister(24, 1); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetRegister(23) == 0); +} + +TEST_CASE("A64: Isolated GetNZCVFromOp", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0xaa1f03f5); // MOV X21, XZR + env.code_mem.emplace_back(0x912a02da); // ADD X26, X22, #0xa80 + env.code_mem.emplace_back(0x913662dc); // ADD X28, X22, #0xd98 + env.code_mem.emplace_back(0x320003e8); // MOV W8, #1 + env.code_mem.emplace_back(0xa9006bfc); // STP X28, X26, [SP] + env.code_mem.emplace_back(0x7200011f); // TST W8, #1 + env.code_mem.emplace_back(0xf94007e8); // LDR X8, [SP, #8] + env.code_mem.emplace_back(0x321e03e3); // MOV W3, #4 + env.code_mem.emplace_back(0xaa1303e2); // MOV X2, X19 + env.code_mem.emplace_back(0x9a881357); // CSEL X23, X26, X8, NE + env.code_mem.emplace_back(0xf94003e8); // LDR X8, [SP] + env.code_mem.emplace_back(0xaa1703e0); // MOV X0, X23 + env.code_mem.emplace_back(0x9a881396); // CSEL X22, X28, X8, NE + env.code_mem.emplace_back(0x92407ea8); // AND X8, X21, #0xffffffff + env.code_mem.emplace_back(0x1ac8269b); // LSR W27, W20, W8 + env.code_mem.emplace_back(0x0b1b0768); // ADD W8, W27, W27, LSL #1 + env.code_mem.emplace_back(0x937f7d01); // SBFIZ X1, X8, #1, #32 + env.code_mem.emplace_back(0x2a1f03e4); // MOV W4, WZR + env.code_mem.emplace_back(0x531e7779); // LSL W25, W27, #2 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + + env.ticks_left = 20; + jit.Run(); +} + +TEST_CASE("A64: Optimization failure when folding ADD", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0xbc4f84be); // LDR S30, [X5], #248 + env.code_mem.emplace_back(0x9a0c00ea); // ADC X10, X7, X12 + env.code_mem.emplace_back(0x5a1a0079); // SBC W25, W3, W26 + env.code_mem.emplace_back(0x9b0e2be9); // MADD X9, XZR, X14, X10 + env.code_mem.emplace_back(0xfa5fe8a9); // CCMP X5, #31, #9, AL + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetRegister(0, 0x46e15845dba57924); + jit.SetRegister(1, 0x6f60d04350581fea); + jit.SetRegister(2, 0x85cface50edcfc03); + jit.SetRegister(3, 0x47e1e8906e10ec5a); + jit.SetRegister(4, 0x70717c9450b6b707); + jit.SetRegister(5, 0x300d83205baeaff4); + jit.SetRegister(6, 0xb7890de7c6fee082); + jit.SetRegister(7, 0xa89fb6d6f1b42f4a); + jit.SetRegister(8, 0x04e36b8aada91d4f); + jit.SetRegister(9, 0xa03bf6bde71c6ac5); + jit.SetRegister(10, 0x319374d14baa83b0); + jit.SetRegister(11, 0x5a78fc0fffca7c5f); + jit.SetRegister(12, 0xc012b5063f43b8ad); + jit.SetRegister(13, 0x821ade159d39fea1); + jit.SetRegister(14, 0x41f97b2f5525c25e); + jit.SetRegister(15, 0xab0cd3653cb93738); + jit.SetRegister(16, 0x50dfcb55a4ebd554); + jit.SetRegister(17, 0x30dd7d18ae52df03); + jit.SetRegister(18, 0x4e53b20d252bf085); + jit.SetRegister(19, 0x013582d71f5fd42a); + jit.SetRegister(20, 0x97a151539dad44e7); + jit.SetRegister(21, 0xa6fcc6bb220a2ad3); + jit.SetRegister(22, 0x4c84d3c84a6c5c5c); + jit.SetRegister(23, 0x1a7596a5ef930dff); + jit.SetRegister(24, 0x06248d96a02ff210); + jit.SetRegister(25, 0xfcb8772aec4b1dfd); + jit.SetRegister(26, 0x63619787b6a17665); + jit.SetRegister(27, 0xbd50c3352d001e40); + jit.SetRegister(28, 0x4e186aae63c81553); + jit.SetRegister(29, 0x57462b7163bd6508); + jit.SetRegister(30, 0xa977c850d16d562c); + jit.SetSP(0x000000da9b761d8c); + jit.SetFpsr(0x03480000); + jit.SetPstate(0x30000000); + + env.ticks_left = 6; + jit.Run(); + + REQUIRE(jit.GetRegister(0) == 0x46e15845dba57924); + REQUIRE(jit.GetRegister(1) == 0x6f60d04350581fea); + REQUIRE(jit.GetRegister(2) == 0x85cface50edcfc03); + REQUIRE(jit.GetRegister(3) == 0x47e1e8906e10ec5a); + REQUIRE(jit.GetRegister(4) == 0x70717c9450b6b707); + REQUIRE(jit.GetRegister(5) == 0x300d83205baeb0ec); + REQUIRE(jit.GetRegister(6) == 0xb7890de7c6fee082); + REQUIRE(jit.GetRegister(7) == 0xa89fb6d6f1b42f4a); + REQUIRE(jit.GetRegister(8) == 0x04e36b8aada91d4f); + REQUIRE(jit.GetRegister(9) == 0x68b26bdd30f7e7f8); + REQUIRE(jit.GetRegister(10) == 0x68b26bdd30f7e7f8); + REQUIRE(jit.GetRegister(11) == 0x5a78fc0fffca7c5f); + REQUIRE(jit.GetRegister(12) == 0xc012b5063f43b8ad); + REQUIRE(jit.GetRegister(13) == 0x821ade159d39fea1); + REQUIRE(jit.GetRegister(14) == 0x41f97b2f5525c25e); + REQUIRE(jit.GetRegister(15) == 0xab0cd3653cb93738); + REQUIRE(jit.GetRegister(16) == 0x50dfcb55a4ebd554); + REQUIRE(jit.GetRegister(17) == 0x30dd7d18ae52df03); + REQUIRE(jit.GetRegister(18) == 0x4e53b20d252bf085); + REQUIRE(jit.GetRegister(19) == 0x013582d71f5fd42a); + REQUIRE(jit.GetRegister(20) == 0x97a151539dad44e7); + REQUIRE(jit.GetRegister(21) == 0xa6fcc6bb220a2ad3); + REQUIRE(jit.GetRegister(22) == 0x4c84d3c84a6c5c5c); + REQUIRE(jit.GetRegister(23) == 0x1a7596a5ef930dff); + REQUIRE(jit.GetRegister(24) == 0x06248d96a02ff210); + REQUIRE(jit.GetRegister(25) == 0x00000000b76f75f5); + REQUIRE(jit.GetRegister(26) == 0x63619787b6a17665); + REQUIRE(jit.GetRegister(27) == 0xbd50c3352d001e40); + REQUIRE(jit.GetRegister(28) == 0x4e186aae63c81553); + REQUIRE(jit.GetRegister(29) == 0x57462b7163bd6508); + REQUIRE(jit.GetRegister(30) == 0xa977c850d16d562c); + REQUIRE(jit.GetPstate() == 0x20000000); + REQUIRE(jit.GetVector(30) == Vector{0xf7f6f5f4, 0}); +} + +TEST_CASE("A64: Cache Maintenance Instructions", "[a64]") { + class CacheMaintenanceTestEnv final : public A64TestEnv { + void InstructionCacheOperationRaised(A64::InstructionCacheOperation op, VAddr value) override { + REQUIRE(op == A64::InstructionCacheOperation::InvalidateByVAToPoU); + REQUIRE(value == 0xcafed00d); + } + void DataCacheOperationRaised(A64::DataCacheOperation op, VAddr value) override { + REQUIRE(op == A64::DataCacheOperation::InvalidateByVAToPoC); + REQUIRE(value == 0xcafebabe); + } + }; + + CacheMaintenanceTestEnv env; + A64::UserConfig conf{&env}; + conf.hook_data_cache_operations = true; + A64::Jit jit{conf}; + + jit.SetRegister(0, 0xcafed00d); + jit.SetRegister(1, 0xcafebabe); + + env.code_mem.emplace_back(0xd50b7520); // ic ivau, x0 + env.code_mem.emplace_back(0xd5087621); // dc ivac, x1 + env.code_mem.emplace_back(0x14000000); // B . + + env.ticks_left = 3; + jit.Run(); +} + +TEST_CASE("A64: Memory access (fastmem)", "[a64]") { + constexpr size_t address_width = 12; + constexpr size_t memory_size = 1ull << address_width; // 4K + constexpr size_t page_size = 4 * 1024; + constexpr size_t buffer_size = 2 * page_size; + char buffer[buffer_size]; + + void* buffer_ptr = reinterpret_cast<void*>(buffer); + size_t buffer_size_nconst = buffer_size; + char* backing_memory = reinterpret_cast<char*>(std::align(page_size, memory_size, buffer_ptr, buffer_size_nconst)); + + A64FastmemTestEnv env{backing_memory}; + Dynarmic::A64::UserConfig config{&env}; + config.fastmem_pointer = backing_memory; + config.fastmem_address_space_bits = address_width; + config.recompile_on_fastmem_failure = false; + config.silently_mirror_fastmem = true; + config.processor_id = 0; + + Dynarmic::A64::Jit jit{config}; + memset(backing_memory, 0, memory_size); + memcpy(backing_memory + 0x100, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 57); + + env.MemoryWrite32(0, 0xA9401404); // LDP X4, X5, [X0] + env.MemoryWrite32(4, 0xF9400046); // LDR X6, [X2] + env.MemoryWrite32(8, 0xA9001424); // STP X4, X5, [X1] + env.MemoryWrite32(12, 0xF9000066); // STR X6, [X3] + env.MemoryWrite32(16, 0x14000000); // B . + jit.SetRegister(0, 0x100); + jit.SetRegister(1, 0x1F0); + jit.SetRegister(2, 0x10F); + jit.SetRegister(3, 0x1FF); + + jit.SetPC(0); + jit.SetSP(memory_size - 1); + jit.SetFpsr(0x03480000); + jit.SetPstate(0x30000000); + env.ticks_left = 5; + + jit.Run(); + REQUIRE(strncmp(backing_memory + 0x100, backing_memory + 0x1F0, 23) == 0); +} + +TEST_CASE("A64: SQRDMULH QC flag when output invalidated", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x0fbcd38b); // SQRDMULH.2S V11, V28, V28[1] + env.code_mem.emplace_back(0x7ef0f8eb); // FMINP.2D D11, V7 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetVector(7, {0xb1b5'd0b1'4e54'e281, 0xb4cb'4fec'8563'1032}); + jit.SetVector(28, {0x8000'0000'0000'0000, 0x0000'0000'0000'0000}); + jit.SetFpcr(0x05400000); + + env.ticks_left = 3; + jit.Run(); + + REQUIRE(jit.GetFpsr() == 0x08000000); + REQUIRE(jit.GetVector(11) == Vector{0xb4cb'4fec'8563'1032, 0x0000'0000'0000'0000}); +} + +TEST_CASE("A64: SDIV maximally", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(0x9ac00c22); // SDIV X2, X1, X0 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetRegister(0, 0xffffffffffffffff); + jit.SetRegister(1, 0x8000000000000000); + jit.SetRegister(2, 0xffffffffffffffff); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetRegister(0) == 0xffffffffffffffff); + REQUIRE(jit.GetRegister(1) == 0x8000000000000000); + REQUIRE(jit.GetRegister(2) == 0x8000000000000000); + REQUIRE(jit.GetPC() == 4); +} + +// Restricted register set required to trigger: +// const HostLocList any_gpr = { HostLoc::RAX, HostLoc::RBX, HostLoc::RCX, HostLoc::R13, HostLoc::R14 }; +// const HostLocList any_xmm = { HostLoc::XMM1, HostLoc::XMM2, HostLoc::XMM3, HostLoc::XMM4, HostLoc::XMM5, HostLoc::XMM6 }; +TEST_CASE("A64: rand1", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem = {0x2ea2e69a, 0x6f7168e7, 0x7eb0f816, 0x6ebd369d, 0x1e65c302, 0x1e63011c, 0x1e67c349, 0x0f861bd6, 0x9e59cbbc, 0x5e61cb8b, 0x6e218b01, 0x4eb2409f, 0x7f7c2452, 0x7e207a8d, 0xd503369f}; + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetRegister(0, 0x67e1d59cc30a788c); + jit.SetRegister(1, 0x0e771a2a79dfb060); + jit.SetRegister(2, 0x35cc7e7831247f7c); + jit.SetRegister(3, 0x63a22cce1f9cde66); + jit.SetRegister(4, 0xb6a022d8406543a3); + jit.SetRegister(5, 0x6712e272c4ad27a0); + jit.SetRegister(6, 0x9d2a01c3bc374837); + jit.SetRegister(7, 0x83bc2f62feb76043); + jit.SetRegister(8, 0x9ba9e8c3d543f1bf); + jit.SetRegister(9, 0xe4aee4636277b787); + jit.SetRegister(10, 0x9cd9e201dacc233b); + jit.SetRegister(11, 0x39e0a5c3bb44efc9); + jit.SetRegister(12, 0xca229296c29f8742); + jit.SetRegister(13, 0x4cdf038f1323ff2d); + jit.SetRegister(14, 0x377ad499a81b1f5a); + jit.SetRegister(15, 0x8217307060f11c6d); + jit.SetRegister(16, 0xd1af2e75ea62dba7); + jit.SetRegister(17, 0x77661148c760e9d6); + jit.SetRegister(18, 0xf05a251f9cf60f9e); + jit.SetRegister(19, 0xf54301927e8fa020); + jit.SetRegister(20, 0x534c76f6f6d6805c); + jit.SetRegister(21, 0x60240c3e727aae2d); + jit.SetRegister(22, 0x52b82c212af254d6); + jit.SetRegister(23, 0xb0ad501210d12c07); + jit.SetRegister(24, 0x596a9119514f3460); + jit.SetRegister(25, 0xa933e19b69b2c6f7); + jit.SetRegister(26, 0x6f3693ec0f5e7708); + jit.SetRegister(27, 0xc6a3908a03fb9737); + jit.SetRegister(28, 0x113ba38d50953b60); + jit.SetRegister(29, 0xbe5395907134511e); + jit.SetRegister(30, 0x9a5d96aa066e5c39); + jit.SetPC(0); + jit.SetSP(0x000000c6bec5a48c); + + jit.SetVector(0, {0x0faa90e6561b1ffb, 0xb8c1c925ee613293}); + jit.SetVector(1, {0x3fa365cf7a4f3eaa, 0xbd0fabf98eb5c061}); + jit.SetVector(2, {0x3d7722d0e4444b00, 0xf30ba88476b79615}); + jit.SetVector(3, {0xf794f4953fb4a413, 0xedd6426638cf0242}); + jit.SetVector(4, {0x1ddfdd8985c58693, 0xc344d565e68ab18b}); + jit.SetVector(5, {0x600fcef72b18ae5f, 0x3af9964747ff06b9}); + jit.SetVector(6, {0x276b755d4452ec74, 0xf5579ddb0f2146b4}); + jit.SetVector(7, {0xd1823739c80439e5, 0xd8c4bc8cf08fce6e}); + jit.SetVector(8, {0x0e4c8796dca46ad0, 0x53293d124cd38d6e}); + jit.SetVector(9, {0x860e30c54fcbe0b8, 0x09c57c6b723e45f5}); + jit.SetVector(10, {0xe3652801c3d11ddb, 0x4ef5f76fa85d28b9}); + jit.SetVector(11, {0xa6c22b4e20d5a3a2, 0x5b98938307afb538}); + jit.SetVector(12, {0x915960a26d2d8c02, 0x0ecdf8bc35c8a184}); + jit.SetVector(13, {0xa79a1f506ed066b4, 0x23de2152171ce4c6}); + jit.SetVector(14, {0xd4b85ed863708645, 0x3cf7b2693ac76d3f}); + jit.SetVector(15, {0x8900b9888729557b, 0x2eeeef32083bf9b9}); + jit.SetVector(16, {0x0b40331c7fc30b54, 0xcb5fb7d6ca96ccca}); + jit.SetVector(17, {0x0040b87ea24910c7, 0x97f925750c5da4c5}); + jit.SetVector(18, {0xf19de744c8c88b3d, 0xa1406fae21f53d8c}); + jit.SetVector(19, {0x02b6e985e99a6a3d, 0xe470d5328c9b2af5}); + jit.SetVector(20, {0x6bfb919ed9752198, 0xcaab56c2adc2c486}); + jit.SetVector(21, {0x4c1dd31e9fb91bae, 0xe1d4a4b936d1dfab}); + jit.SetVector(22, {0x5d8c08ee0dbe758a, 0xb1b25da077a0ba26}); + jit.SetVector(23, {0xf1f3377346a6e4db, 0x4995274fe7e17908}); + jit.SetVector(24, {0xa1c4d7cca6fe8a95, 0xb267a94646819606}); + jit.SetVector(25, {0x8bbe1a250a008e73, 0xc729df1ac7eeb7d3}); + jit.SetVector(26, {0x48c23bc8ce6857d5, 0x35bb31ef278268d7}); + jit.SetVector(27, {0x0473d63f3f0c5075, 0xf4bb5d79938901f4}); + jit.SetVector(28, {0x01e2930f7313493e, 0xdc6ef4adadcc8e37}); + jit.SetVector(29, {0x2c500da43b460d13, 0x7bb4520d5580a648}); + jit.SetVector(30, {0xdf4e3d139b825da0, 0x19fea0310522fda2}); + jit.SetVector(31, {0xf8b440b8d5e25111, 0x73758151a32b6b13}); + + jit.SetPstate(0x60000000); + jit.SetFpcr(0x01080000); + + env.ticks_left = 16; + jit.Run(); + + REQUIRE(jit.GetRegister(0) == 0x67e1d59cc30a788c); + REQUIRE(jit.GetRegister(1) == 0x0e771a2a79dfb060); + REQUIRE(jit.GetRegister(2) == 0x35cc7e7831247f7c); + REQUIRE(jit.GetRegister(3) == 0x63a22cce1f9cde66); + REQUIRE(jit.GetRegister(4) == 0xb6a022d8406543a3); + REQUIRE(jit.GetRegister(5) == 0x6712e272c4ad27a0); + REQUIRE(jit.GetRegister(6) == 0x9d2a01c3bc374837); + REQUIRE(jit.GetRegister(7) == 0x83bc2f62feb76043); + REQUIRE(jit.GetRegister(8) == 0x9ba9e8c3d543f1bf); + REQUIRE(jit.GetRegister(9) == 0xe4aee4636277b787); + REQUIRE(jit.GetRegister(10) == 0x9cd9e201dacc233b); + REQUIRE(jit.GetRegister(11) == 0x39e0a5c3bb44efc9); + REQUIRE(jit.GetRegister(12) == 0xca229296c29f8742); + REQUIRE(jit.GetRegister(13) == 0x4cdf038f1323ff2d); + REQUIRE(jit.GetRegister(14) == 0x377ad499a81b1f5a); + REQUIRE(jit.GetRegister(15) == 0x8217307060f11c6d); + REQUIRE(jit.GetRegister(16) == 0xd1af2e75ea62dba7); + REQUIRE(jit.GetRegister(17) == 0x77661148c760e9d6); + REQUIRE(jit.GetRegister(18) == 0xf05a251f9cf60f9e); + REQUIRE(jit.GetRegister(19) == 0xf54301927e8fa020); + REQUIRE(jit.GetRegister(20) == 0x534c76f6f6d6805c); + REQUIRE(jit.GetRegister(21) == 0x60240c3e727aae2d); + REQUIRE(jit.GetRegister(22) == 0x52b82c212af254d6); + REQUIRE(jit.GetRegister(23) == 0xb0ad501210d12c07); + REQUIRE(jit.GetRegister(24) == 0x596a9119514f3460); + REQUIRE(jit.GetRegister(25) == 0xa933e19b69b2c6f7); + REQUIRE(jit.GetRegister(26) == 0x6f3693ec0f5e7708); + REQUIRE(jit.GetRegister(27) == 0xc6a3908a03fb9737); + REQUIRE(jit.GetRegister(28) == 0x0000000000000000); + REQUIRE(jit.GetRegister(29) == 0xbe5395907134511e); + REQUIRE(jit.GetRegister(30) == 0x9a5d96aa066e5c39); +} + +TEST_CASE("A64: rand2", "[a64][.]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{.callbacks = &env, .fastmem_pointer = reinterpret_cast<void*>(0xffffffff00000000)}}; + + env.code_mem = {0xea80f352, 0x6e65e59d, 0x1e20c343, 0x2e3a7192, 0x2e267249, 0xd500405f, 0x6f01f461, 0x6eb684fc, 0x58028edd, 0x0ea5f5b6, 0x0ea069fb, 0x2e769517, 0x5e066063, 0x1e65c3f5, 0x4f00ff52, 0x93401cf6, 0x1e274248, 0x6f67aaf5, 0x5e0c0782, 0x5ef43f3c, 0x2e6595b7, 0x4e20590f, 0xb35aa451, 0x6ee2c5ed, 0x4e32bf46, 0x2ea1ba8f, 0x2f68a85e, 0x9237d90a, 0x5e23dd10, 0x0e762e32, 0x4e31a8cf, 0xce1f3360, 0x781a4ac0, 0x13834066, 0x5fa8101c, 0x6f7c5594, 0x0e71bb68, 0xbc0b3e8f, 0x785dbbda, 0x6f51e794, 0xce50af75, 0x1ad728ec, 0x6ee0da4c, 0xb84efa14, 0x2eb3f613, 0x4e287ade, 0x4eb8c734, 0x2e83f4e8, 0x0e397c80, 0xd08f93f8, 0xce718e48, 0x0f672a0d, 0x2e9edd40, 0x0e14128b, 0x6f5942e6, 0x8b3a0f03, 0x3c5d16b9, 0x7f7e3743, 0x4f4c54e4, 0x0ea0a9e9, 0x9e59dbe6, 0x6e7ddcd3, 0xcec08377, 0x9ba759f8, 0x2ea5046e, 0x0e24c569, 0xb8979780, 0x4e31b98c, 0x4efe4f46, 0x4ea7c762, 0x7e61c9c6, 0x6e30c880, 0x1ada0c25, 0x4e603a2f, 0xda9d7218, 0x0d40c5d9, 0x5e214b05, 0x9ba9efc5, 0x5e61b81e, 0x6e7bc31c, 0x0e61a163, 0x9e5832d2, 0x4e772248, 0x4e3d17c8, 0x92624f60, 0x7a1a02dc, 0x79891f65, 0x6eb45036, 0x0e321ee8, 0x4e2566f0, 0x4ea02b9b, 0x0f9dcb3d, 0x2e21b9f9, 0x0e21a8c3, 0xda1700bd, 0x6ea0fb38, 0x7e607a0b, 0x72845817, 0x7f61068e, 0x0d60e529, 0x4ea0ca5c, 0x1a94b20f, 0x8b87419d, 0x7ea9ed71, 0x2ea1a86e, 0x4d40c4da, 0x5ea0eada, 0x784ba96e, 0x7eb6ee02, 0x3db1c710, 0x0e217836, 0x7ee0bb96, 0x4e786c08, 0x4e976a08, 0x489ffe86, 0x4e79fc9b, 0x0e21cbce, 0x5ef7fc65, 0x4ea1286d, 0xd29c771e, 0x6f5c2839, 0x0ea00a9d, 0x6ee44c06, 0x5ee1d858, 0x5ef2fda6, 0x7eb0c9fe, 0x7f762791, 0x2e212ae6, 0x4e61c9db, 0x13003c57, 0x5ee1b8f8, 0x0f2396d2, 0x6ea0db1e, 0x0e71ba82, 0xab29c807, 0x6ef8f8b3, 0x1f18d4a1, 0x0e261d15, 0x1e290081, 0x1b0c7d12, 0x4e7771c3, 0xf845f1e4, 0x4d40c9e8, 0xce778452, 0x6eb9879d, 0x6e21c93d, 0xcec0829f, 0x52a0969f, 0x1e772b4f, 0x7ee1da88, 0x5f52fe0a, 0x7f3387b1, 0x5e214850, 0x1e65c025, 0x0e2ca294, 0x2e614829, 0x1e640077, 0x9e240048, 0x4ebe9537, 0x9bb7925e, 0x38b669c5, 0x2840d089, 0x6f43e648, 0x2e662d28, 0x4eabaff3, 0x6e734cc7, 0x0e31baee, 0x7ee0d93c, 0x5e282bde, 0x7e21bba4, 0x4e6c75fa, 0x5ac01217, 0x7f4304af, 0x1e7878ed, 0x1ada2196, 0x7ee1aba3, 0x93407f3c, 0x4f6c34eb, 0x6e3447a9, 0x7e7ae545, 0x5e0802bb, 0x6eeae63a, 0x7ee1da62, 0x5e280bb3, 0xf81d4009, 0x1e603b21, 0x5e281a14, 0x6eb0a99b, 0x1e266a25, 0x0d60cafe, 0x0e0b6194, 0x7a4ed2c5, 0x92b762ec, 0x4e6b5749, 0x3c16a6e5, 0x4ea0a92b, 0x0fa58b6a, 0x5f76148c, 0x6e30c95f, 0x1e6540fd, 0x5e28e40f, 0x0d403fd4, 0x7e30da36, 0x7fda9b51, 0x2ea04bde, 0x1e25c3d2, 0x1ee0434c, 0x5e21d8e7, 0x5ee1ba51, 0x5e61aba9, 0x4e2849fb, 0x5ee098ea, 0x4e60f63d, 0x0f280443, 0x5ee0da27, 0x2e78a6ce, 0x78054afc, 0x4e14286b, 0x4e218bd8, 0x2a3d2551, 0x3a04017a, 0x5f4317cd, 0x0e604a37, 0x9a834614, 0x0e2edf4d, 0x7a51a0a0, 0x5f8e9043, 0x6ea06bb2, 0xaa2857dd, 0x7a1903fc, 0x301ba9ba, 0x9ac929cd, 0x4e061ff0, 0x2e38fcfc, 0x0e2f614a, 0x7ee0d8e4, 0x6e73afda, 0x7f4156f7, 0x0e6078bf, 0x4ee1d9ed, 0x93403fbe, 0xce6f8640, 0x4e3855e3, 0x6f76fe23, 0x112466e8, 0x1e358a90, 0x7f45272c, 0x6ea19a9d, 0x8a696350, 0x1e3900f6, 0x5e61c866, 0x0e3fbfd0, 0x5ee09ad0, 0x0e651d27, 0x4dffc35e, 0x2e20c6ce, 0x0fbe118d, 0x1e656a15, 0xd1357365, 0x0e20a847, 0xce4a835c, 0x4e203905, 0x2e60090d, 0x7f4a27bb, 0x1e64c316, 0xce7d86a4, 0x7ebded2d, 0x6e70a97e, 0x4eb9a42b, 0x0e209bef, 0x6f151730, 0x0e7e30f7, 0x4e724509, 0xd503375f, 0xce58b6ae, 0x5e21a9b8, 0xcb2ca538, 0x5ac01131, 0x6ea19a24, 0xeb40c8b3, 0xc8df7d65, 0x78108341, 0x3218ab9b, 0x0f3da7dd, 0x2e003089, 0x4e21cab5, 0x8aa5c924, 0x1a94950c, 0x123e506f, 0x13117e37, 0x1ee6005b, 0x5ac00647, 0x5eec8cd5, 0x7ef0fb3d, 0x9223272a, 0x5ee0cb02, 0x6e66071d, 0x6ea1dbbf, 0x5e61c903, 0x5ac015ea, 0x93db6206, 0x7e62b5e3, 0x6ea0c87b, 0xdac0090e, 0x48df7d90, 0x6e206ba5, 0x9e2503c2, 0x6e25fc89, 0x4d60e2db, 0x1e3e22a0, 0x2eb81c19, 0x7856ea00, 0x5fbfb22d, 0x1e630244, 0x4e202a83, 0x1f50a722, 0x7f7b55d2, 0x0fae89b9, 0x4e781d73, 0xce738c3a, 0x4f15a591, 0x6e21c7e1, 0x586ff77e, 0x8a5d3592, 0x93401c67, 0x5e61cb86, 0xce6bc2c1, 0x6e393f10, 0x9bb70ec3, 0xdac0098c, 0x4da84b95, 0x7f494476, 0x9ace5c11, 0x7e61ca14, 0x4f7a60ef, 0x1ad32b39, 0x0ea3777f, 0x5e61da7f, 0x4f1404e2, 0x4e3244e2, 0x6e1b1ceb, 0x0dee5aac, 0x4e2f9dc4, 0x5ea1b8c3, 0x1e59f863, 0xd500403f, 0x4e3ae7d0, 0x4ef5c6ea, 0x08dffe3b, 0x6e36f4f6, 0x2e764f29, 0x0e726f23, 0x5f42375b, 0x7f71fc40, 0x6e618aad, 0x93403e5b, 0x0e205976, 0x0e7250c4, 0x6eb0abc9, 0x2e2049f0, 0x5f14754d, 0x7f6ce468, 0x6f950bbe, 0x6e31aa47, 0x4eb83396, 0x0dccc952, 0x2ea1ca90, 0xce69c701, 0xb0bed69e, 0x7c5dec39, 0x4e2868a2, 0x0e591b08, 0x5f34e6dd, 0x3a449184, 0x5e3ce6de, 0x4ea149b7, 0x4e7ad29b, 0xba198503, 0x1f683e8f, 0xfa52f2a7, 0x6e30dffc, 0x4e6c3d17, 0x2eae3248, 0xd503349f, 0x1e60002c, 0x0f180680, 0x9e240049, 0x6f75774e, 0xa90d8678, 0x9ad924c4, 0x7eb0f85b, 0x0e205aaf, 0x7ee08899, 0x5f4bffd8, 0x1b0ff5f3, 0x4ee11dcd, 0x2e218948, 0x0dcb2733, 0x4eac107c, 0x4ea04a53, 0x4e287b44, 0x0e60b82a, 0x5ee0ebbc, 0xce454ff1, 0x5e1761e7, 0x5e09202f, 0x0e0c0754, 0x1e72e6b9, 0x7e21da70, 0x0fbdb20c, 0x5efb8c84, 0xd500401f, 0x3a47526e, 0x1e680acf, 0x7f7375fc, 0xf80522da, 0x4ee60c02, 0x4d40c2e7, 0x6f89096b, 0x7ee1bb6e, 0x5e280b4a, 0x1e3120c8, 0x7eb2ef96, 0x4fd012dd, 0x0f3027ef, 0x4e2078a8, 0xd503201f, 0x2e2312d9, 0x6ebf1c6e, 0x5ee1f8df, 0x4e607a46, 0x6e30c877, 0x6c09d2d1, 0x4e61abd8, 0x0e35267e, 0x6ac17728, 0x0e861aa0, 0x6f63fe26, 0x6f157628, 0x6f30a5f9, 0x4d60cc0c, 0x4e21cb59, 0x2e68a3fb, 0x7efae601, 0x6ea0f82c, 0x9b25ec12, 0x1a1a0305, 0x0e043fe1, 0x6e73c0ed, 0x6ea1b8c0, 0x7e20380b, 0x0f0534e8, 0x1f56bc7d, 0xba0c0128, 0x1e672160, 0x6e7b259b, 0x7ee07b5d, 0x9a820443, 0x4e040581, 0x2f1d87e8, 0x1acd2f5b, 0x6e20794f, 0x2e6a3c93, 0xc8dffe13, 0xce5ab1c6, 0x6eea55f6, 0x4ea039b3, 0x0d602fec, 0x2e246e2f, 0x7857be39, 0xb80608fb, 0x1e67c017, 0x9bcf7f63, 0x0f92d857, 0x5e0812f7, 0x1e210172, 0x7e6128e9, 0x7ea94d41, 0x981179e1, 0x1effb018, 0x2e600828, 0x0eb9c6b2, 0x6ee1baae, 0x4ea0db28, 0x2ea1487b, 0x4ea6c7f0, 0x2e2374c7, 0x7e30d8dd, 0xb9991fa7, 0x4e791e3e, 0x889f7c4b, 0x0e6c753c, 0x1e740ad1, 0x1e244324, 0x1ef33010, 0x5ac01102, 0x9bd97fba, 0x6e290143, 0x1e2220d8, 0x4d8d5aee, 0x6f28570b, 0xfa4ab0c1, 0xdac00b14, 0x7ea1a90e, 0x2e3027d8, 0x6f25a733, 0x4e61a96e, 0x4e1a2fcb, 0x0e22fe0a, 0xc8df7cd0, 0x5e280a55, 0x4e012b20, 0x7e70dbf4, 0x520c5a4e, 0x6ea6c57f, 0x0e861af8, 0xd503233f, 0x889ffe3c, 0x5e274ea9, 0x4e21a89a, 0x0e170c02, 0x6efd4c0b, 0xd5033ebf, 0x6e61a92c, 0x2e205b72, 0x789fb828, 0x0e626e94, 0x2ea6724c, 0x9a10028b, 0x2c6c51fc, 0x5a9de6b9, 0x6e6881f3, 0x5ee0ea6b, 0x0faec36e, 0x0e955bca, 0x1acf206d, 0x7f6f571b, 0x4e286930, 0x12b41ceb, 0x1e770b7a, 0x0ea18ac2, 0x5e282aaf, 0xf2b7fa1e, 0x1ac34311, 0x13167d11, 0x4ea63412, 0x6e758038, 0x2f1d85d6, 0x0f275480, 0x0ead6c71, 0x6e204b69, 0x1e6303f4, 0x5e0031ef, 0x13001e40, 0x7a16006f, 0x6e6ae4c0, 0x0f0f242f, 0x6e674f50, 0x4e606b7a, 0x7e6ee684, 0x1e6b5957, 0x7ea1bbab, 0x7ea0b6cb, 0xce4da241, 0x0ea1b953, 0x0eb2af4b, 0x9ac309d0, 0x6e61d8bd, 0x5ea0d890, 0x5f47d1e7, 0xfa5981ca, 0x1e7f7959, 0x6ef24dd8, 0x0e0a41d1, 0x5ee0e898, 0x4e6038e2, 0x13097d65, 0x6f839088, 0x9e290265, 0x0e208824, 0x2e65af79, 0x6f36a561, 0x9ad3204b, 0x0e21482e, 0x1e24431d, 0xd50330bf, 0x0df641aa, 0x6e602a83, 0xce30505f, 0x5e025238, 0xd503201f, 0x4e608880, 0x4de9c38d, 0x5e0f5348, 0x6eb48ca9, 0x50fda31b, 0x2e251eec, 0x7842ba50, 0xd8a1cd86, 0x2ea09862, 0x0ea09983, 0x2ea333b0, 0x0ea6032c, 0x4f94801b, 0x7e3ee57d, 0x38135e4f, 0xd8fdd9dd, 0x5ee0fcde, 0x9e64033d, 0x6e37f547, 0x6e3dd7ef, 0x13003f3d, 0x0e602f9f, 0x4e7ad014, 0x9b3b6857, 0x5ea0cb67, 0x0eb31c9f, 0x4e7c5372, 0x5e61b8c0, 0x0ea19b23, 0x0ee6e1df, 0x6e63a626, 0x2f139405, 0x7eb0f96d, 0x9e588c63, 0x2e714c3a, 0x6e8c941e, 0x0f61b331, 0x6f01f625, 0x4e78d4ea, 0x6f403709, 0x1a0300da, 0xda0102c8, 0x7e61d9fd, 0xb89469bb, 0x0c838780, 0x2e60a590, 0x4dfd29e1, 0x4e150f2e, 0xce2810bc, 0x5f541591, 0x9ee60259, 0x2eb40e56, 0x5e014027, 0x2ef71faf, 0x4e2d452f, 0x5ee0a813, 0x4eb03301, 0x38443acf, 0x6eabd502, 0x0e2ee71e, 0x5a960364, 0xce7ec596, 0x7efbed09, 0x4ef42ea2, 0x0eb30ea5, 0x5ee0d9f8, 0x6f513552, 0xf89eb3fa, 0x7ea2eca6, 0x9b00cc19, 0xf897409e, 0x1e73485f, 0x381afa77, 0x0f169f3b, 0x5ee1aa70, 0x5e1803ee, 0x0dbf5a4c, 0xce78c7a6, 0x9b0b260c, 0x2ef8fa19, 0x6e70aa4b, 0xce45b805, 0x2ea08e86, 0x4ee0bafd, 0x2ea09a1f, 0x4e218900, 0x6e744f13, 0xce518653, 0xf81b7a68, 0xce45ac5e, 0x7e62e416, 0x1a1b02b6, 0x7e21db48, 0x381daaaf, 0x6b2c0987, 0x0e2ec651, 0x4eae8502, 0x9bde7ca0, 0x6f47201f, 0x7e61a8a3, 0x6e60d5db, 0x4e2879de, 0xf81d194e, 0x4f1b8d05, 0x4d0048b2, 0x6e203be9, 0x4e3e7eb1, 0x0e260ef8, 0x2e688518, 0x7e3fec46, 0xdac00843, 0xf85c8917, 0x2e212a0f, 0x0e8196da, 0xd503359f, 0xce4c81f2, 0x6ee19992, 0x6e21ca79, 0x4d40c1d2, 0x4f5816ef, 0x4e34c3ea, 0x4df7c283, 0x7ef7eeb6, 0x18e276ce, 0xab0d21c0, 0xd5032f7f, 0x4ea00dbf, 0x5ac01251, 0xd0121955, 0x7f1495e4, 0x7ef0fa11, 0x5e24dd9c, 0x9add25b5, 0x0eb2bdef, 0x9e1977c7, 0x6f4b26bd, 0x0e200a9c, 0x9b4f7c00, 0x0ea0392e, 0x7e212a2c, 0x0b248b90, 0x1acc27a1, 0x2e701c90, 0x5ee1b870, 0x5e280aba, 0x5ea0780e, 0x1e264246, 0x4e052d04, 0x0e731dc4, 0xce461997, 0x9a9e9413, 0x3d462048, 0x5ea1fac5, 0x2ea0c8c4, 0x9a030280, 0x2ebda4b8, 0x5eef8614, 0x6eadc4e0, 0xbd035a8f, 0x4e606b84, 0x4eb1aba1, 0x4e286928, 0x4e2858cc, 0x9add0ce9, 0x4e070d65, 0x5fd399d5, 0x0f03fde7, 0x6ee90c74, 0x4ef8e31e, 0x381d986a, 0x5ea0ebf4, 0x5ea0d87e, 0x2e76ac9e, 0x6eb36cd4, 0x2e6e1c4c, 0x2e2feebc, 0x1ace4b03, 0x5ee0db12, 0x5ea0e9b1, 0x2e1c32d5, 0x5fa49a09, 0x0e258737, 0x7e21ca8e, 0xce4f9988, 0x5f7f56a6, 0x0e739766, 0x4e28586c, 0x6e619908, 0xd500401f, 0xf88b9252, 0x6e251c8e, 0x9e20015b, 0x7f1486b9, 0x717c339b, 0x1f31ff70, 0x4ea0eb62, 0x9acb0926, 0x489f7d85, 0x4e209b54, 0x2e84cf03, 0x2e65946c, 0x0e7d80cd, 0xc8dffecc, 0xce668bd8, 0x6e2188af, 0xeb4ada34, 0x2b25ec33, 0x0d40e6e7, 0x4eb2c757, 0x4ec82ad0, 0x7e21cb0a, 0x0e21a847, 0x4e0b1ec0, 0x381e6ac0, 0x6e61c8f5, 0x0f10071c, 0x2ee21daa, 0x5e61ab31, 0x6e218892, 0x2e7e7cb5, 0x6f2826aa, 0x7f6b54df, 0x4eaa2620, 0xdac00034, 0x4f6477be, 0x7e6148ea, 0x4eef1f57, 0x78459aeb, 0x2ebc3f10, 0x2e35f4eb, 0x4fbf19ce, 0xd8d0e58e, 0x2e21bbc7, 0x6ee0cab6, 0x9bc57e3f, 0x2f854037, 0x4e92181c, 0x6e6d1f89, 0x0f305545, 0x4ee19a57, 0x0e887bdf, 0x5e1a4185, 0x7ef0c821, 0x2eb6607c, 0x2ea0d9b8, 0x9e0380f4, 0x2ebf1c83, 0x1e62597d, 0x7f6e2548, 0x5ac00205, 0x4e616adb, 0xce638b8c, 0x5e1653cf, 0x2e6069be, 0x0e2ac641, 0x1e33c76f, 0xce44956d, 0x9bb90d31, 0x1e24c20a, 0x7ee038c1, 0x93407e5e, 0x4e280127, 0xc8df7f7d, 0xba42f263, 0x1e6f199c, 0x6e212889, 0x6e92f60e, 0x6ebdc499, 0x8b9acbf8, 0x4d40c581, 0x3a020250, 0x6e6a6716, 0x9248403b, 0x9081ffea, 0x4e603856, 0x9ad1242b, 0x6f270579, 0x1a070349, 0xcec08133, 0xd503305f, 0x5a1a00ca, 0x2e60b8a2, 0x0e5f28fd, 0x0e31a3da, 0x7e61cbc1, 0xd503399f, 0x5f5e54aa, 0x0eb8bdea, 0x4eba8f10, 0x4e2a2e60, 0x2f3da7d6, 0x1e58e297, 0x6e71aa3e, 0x6b86701a, 0xce4fa5e6, 0x4ee7c463, 0x8a79307f, 0x0ebea541, 0x2e218af4, 0x4e774f8a, 0xb9b95dc5, 0x6e61abd5, 0x4dd1e814, 0x4da72098, 0x98307582, 0x3a512101, 0x7ef95497, 0x1ace5535, 0x5a0c0349, 0x4e28581b, 0x6ebf1c02, 0x5ea1da23, 0x1e274314, 0x5e25dd29, 0x6e75f594, 0x6eaf6ed5, 0x4e214abe, 0x4e064172, 0x2e21c8f4, 0xf84c5b08, 0x1e244312, 0x14000000}; + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetRegister(0, 0x866524401a1d4e47); + jit.SetRegister(1, 0x02ca8cec51301b60); + jit.SetRegister(2, 0x0d2e0921242a853d); + jit.SetRegister(3, 0x5ce3dda7d19ec198); + jit.SetRegister(4, 0x8a608e22fb3f50d9); + jit.SetRegister(5, 0x97eab1c959f550bb); + jit.SetRegister(6, 0xdb6d004e7503e72a); + jit.SetRegister(7, 0xbc585cf4f01fee85); + jit.SetRegister(8, 0xd7873927978802ca); + jit.SetRegister(9, 0xf64d146839cc0275); + jit.SetRegister(10, 0xada655f0c8013f78); + jit.SetRegister(11, 0x9c06b18d34ad718a); + jit.SetRegister(12, 0xaa46ab9693a7549f); + jit.SetRegister(13, 0xdc0392ca7ded1f12); + jit.SetRegister(14, 0xb86b5a280b452d1e); + jit.SetRegister(15, 0x4cafeaf58ccf472e); + jit.SetRegister(16, 0x21fcba85c1ed26ba); + jit.SetRegister(17, 0xca8075f2eb56e277); + jit.SetRegister(18, 0x3f06bc758608d762); + jit.SetRegister(19, 0xbbc5a0aecff698e5); + jit.SetRegister(20, 0x02170439baa29e14); + jit.SetRegister(21, 0x0e7a29e1ab81b89b); + jit.SetRegister(22, 0xe8af1b958d645884); + jit.SetRegister(23, 0x86691d7e0500e2e9); + jit.SetRegister(24, 0x4983e6e57f0602c1); + jit.SetRegister(25, 0x4077d562a05048c5); + jit.SetRegister(26, 0x7019154cfcba3e12); + jit.SetRegister(27, 0xfb17997ce5f6a4ce); + jit.SetRegister(28, 0x6eb7a6b778e3dbca); + jit.SetRegister(29, 0x2ca051e70a4743be); + jit.SetRegister(30, 0x91fcc5fdd8a78378); + jit.SetPC(100); + jit.SetSP(0x000000cdfadeaff0); + + env.code_mem_start_address = 100; + + jit.SetVector(0, {0x4d5a180ac0ffdac8, 0xfc6eb113cd5ff2a8}); + jit.SetVector(1, {0x39f8cecc9de9cefd, 0x3a6b35d333d89a6b}); + jit.SetVector(2, {0x791fd8290bbdd2f4, 0xdc0e5e7aee311411}); + jit.SetVector(3, {0xd97db4cbd67fe7de, 0x50042a5e0b94f71c}); + jit.SetVector(4, {0xe2b93543509f65a7, 0xaa1b6433c337c5b9}); + jit.SetVector(5, {0xd93ee9fc22c5edf7, 0xe9042e8f2a2279d3}); + jit.SetVector(6, {0x988cf27e5c9928ad, 0xc1a39aa7429018af}); + jit.SetVector(7, {0x8f24fd7c96752d5e, 0x211ed066df4bf60d}); + jit.SetVector(8, {0xec12260921aa0e5d, 0xcb98d7c3aa39bb54}); + jit.SetVector(9, {0x8ae0d63bef16836b, 0x54b582f6c7c563d5}); + jit.SetVector(10, {0xd36cb5833320a802, 0x94afbd35a90c0d01}); + jit.SetVector(11, {0xf80d24f3de920bb5, 0x8505fd820fdca5ac}); + jit.SetVector(12, {0xc4d5ee040479c10a, 0xb9a65305f855b401}); + jit.SetVector(13, {0xe258117dea0e2e1d, 0x50b6e47f2cbbf98f}); + jit.SetVector(14, {0x8c46631befe40367, 0x76ef634acc1d252e}); + jit.SetVector(15, {0x31ba2e4997445a39, 0xeea2b7e296ed9a10}); + jit.SetVector(16, {0xb1b6ad7f6888ad82, 0x22d61f3a89e351f2}); + jit.SetVector(17, {0x38556d902cb1e166, 0xd94cd8ece8871a9b}); + jit.SetVector(18, {0x8022388e51111894, 0x8319843c0f97c296}); + jit.SetVector(19, {0x80950f4f1988738e, 0x2b51d501a2ac843e}); + jit.SetVector(20, {0xd959d91895a0e304, 0xd86a18f9fbca97cd}); + jit.SetVector(21, {0x9b06de585c91b8f6, 0x6a27b488c3137c9c}); + jit.SetVector(22, {0x95970398b8941fde, 0x85f81fbbf5989d74}); + jit.SetVector(23, {0x33926666f9db44d7, 0xf36ed3933d067e0f}); + jit.SetVector(24, {0x1aefb2ab9a149525, 0xbff5abf69badf81f}); + jit.SetVector(25, {0x88492c5b044f4d83, 0x3fc4029fe302c62c}); + jit.SetVector(26, {0x0cfcc374a4866662, 0xcec449f82b95bc0f}); + jit.SetVector(27, {0x54506ca290052cf6, 0x22f41aa29a475adb}); + jit.SetVector(28, {0x7baf46a55161f432, 0xe7426c082b417919}); + jit.SetVector(29, {0x03a801b9d543654e, 0xb78f7f602ad245ee}); + jit.SetVector(30, {0x656014c093d5ef4a, 0x180caaef9d32e7ab}); + jit.SetVector(31, {0xb6f6e9d497f143b9, 0x1c52381350356431}); + + jit.SetPstate(0xb0000000); + jit.SetFpcr(0x01000000); + + env.ticks_left = 110; + jit.Run(); + + REQUIRE(jit.GetVector(0) == Vector{0x0101010211914707, 0x090000007fd9991a}); + REQUIRE(jit.GetVector(1) == Vector{0x00000000fffffffe, 0x0000000000000000}); + REQUIRE(jit.GetVector(2) == Vector{0x05004503877a2f45, 0x0000000000000000}); + REQUIRE(jit.GetVector(3) == Vector{0x000000007f800000, 0x0000000000000000}); + REQUIRE(jit.GetVector(4) == Vector{0xffffffff00000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(5) == Vector{0xda00894d7886d0bb, 0x5cc5a3b2ca6afb26}); + REQUIRE(jit.GetVector(6) == Vector{0x0000000000000000, 0xfffffffd00000000}); + REQUIRE(jit.GetVector(7) == Vector{0x0000000000000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(8) == Vector{0x0000000000000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(9) == Vector{0x00000000ff800000, 0x0000000000000000}); + REQUIRE(jit.GetVector(10) == Vector{0xc000000000000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(11) == Vector{0xffff000000000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(12) == Vector{0x0c0bd08451d5d9b3, 0x0000000000000000}); + REQUIRE(jit.GetVector(13) == Vector{0x0000000000000000, 0xdc1e34ac00000000}); + REQUIRE(jit.GetVector(14) == Vector{0x00000000ffffffff, 0x0000000000000000}); + REQUIRE(jit.GetVector(15) == Vector{0xfbdfff7cf38fba7d, 0xfffffffffffffffe}); + REQUIRE(jit.GetVector(16) == Vector{0x0000000000000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(17) == Vector{0x0000000000000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(18) == Vector{0x00000000ffffffff, 0x0000000000000000}); + REQUIRE(jit.GetVector(19) == Vector{0x0000000000000000, 0x090000007fd9991a}); + REQUIRE(jit.GetVector(20) == Vector{0x0000000000000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(21) == Vector{0xdbdad9d8dbdad9d8, 0xdbdad9d8dbdad9d8}); + REQUIRE(jit.GetVector(22) == Vector{0xdbdad9d8dbdad9d8, 0xdbdad9d8dbdad9d8}); + REQUIRE(jit.GetVector(23) == Vector{0xffffffff00000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(24) == Vector{0xffffffffffffffff, 0x0000000000000000}); + REQUIRE(jit.GetVector(25) == Vector{0x0000007f00000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(26) == Vector{0x0000000000000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(27) == Vector{0x3a7d96116b237d60, 0x0c6bd37dd698d82a}); + REQUIRE(jit.GetVector(28) == Vector{0x8000000000000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(29) == Vector{0xb3b2000000000000, 0x0000000000000000}); + REQUIRE(jit.GetVector(30) == Vector{0x0000000000000000, 0x8080808080808080}); + REQUIRE(jit.GetVector(31) == Vector{0xb3b2b3b200000000, 0x0000000000000000}); +} + +TEST_CASE("A64: SABD", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; + code.SABD(V0.B16(), V3.B16(), V4.B16()); + code.SABD(V1.H8(), V5.H8(), V6.H8()); + code.SABD(V2.S4(), V7.S4(), V8.S4()); + + constexpr std::array<Vector, 9> vectors = { + // expected output vectors (int8, int16, int32) + Vector{0xa8'4a'cd'0f'7b'2b'78'49, 0x00'ff'88'01'29'34'10'1d}, + Vector{0x1b8c'83cc'4640'37e5, 0x1696'ab90'3d96'2155}, + Vector{0x1c656335'733d91c4, 0x1a488da4'b025dc65}, + // int8 input vectors [3-4] + Vector{0x81'60'7e'60'c4'd6'20'34, 0x12'7f'f7'00'3f'db'0b'a0}, + Vector{0x29'16'b1'6f'3f'ab'a8'7d, 0x12'80'7f'ff'16'0f'fb'83}, + // int16 input vectors [5-6] + Vector{0x8bbd'c450'2dd9'7179, 0xf171'966c'33f2'423b}, + Vector{0xa749'481c'e799'3994, 0xdadb'41fc'f65c'20e6}, + // int32 input vectors [7-8] + Vector{0x57816e27'df8b9293, 0xe1808186'495e497a}, + Vector{0x73e6d15c'52c92457, 0xfbc90f2a'99386d15}, + }; + + jit.SetPC(0); + jit.SetVector(3, vectors[3]); + jit.SetVector(4, vectors[4]); + jit.SetVector(5, vectors[5]); + jit.SetVector(6, vectors[6]); + jit.SetVector(7, vectors[7]); + jit.SetVector(8, vectors[8]); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + CHECK(jit.GetVector(0) == vectors[0]); + CHECK(jit.GetVector(1) == vectors[1]); + CHECK(jit.GetVector(2) == vectors[2]); + + // ensure the correct results are not being produced randomly + jit.SetPC(0); + jit.SetVectors(std::array<Vector, 32>{}); + jit.SetVector(3, vectors[4]); + jit.SetVector(4, vectors[3]); + jit.SetVector(5, vectors[6]); + jit.SetVector(6, vectors[5]); + jit.SetVector(7, vectors[8]); + jit.SetVector(8, vectors[7]); + + env.ticks_left = 4; + jit.Run(); + + CHECK(jit.GetVector(0) == vectors[0]); + CHECK(jit.GetVector(1) == vectors[1]); + CHECK(jit.GetVector(2) == vectors[2]); +} + +TEST_CASE("A64: UZP{1,2}.2D", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; + code.UZP1(V2.D2(), V0.D2(), V1.D2()); + code.UZP2(V3.D2(), V0.D2(), V1.D2()); + + jit.SetPC(0); + jit.SetVector(0, {0xF0F1F2F3F4F5F6F7, 0xE0E1E2E3E4E5E6E7}); + jit.SetVector(1, {0xA0A1A2A3A4A5A6A7, 0xB0B1B2B3B4B5B6B7}); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + REQUIRE(jit.GetVector(2) == Vector{0xF0F1F2F3F4F5F6F7, 0xA0A1A2A3A4A5A6A7}); + REQUIRE(jit.GetVector(3) == Vector{0xE0E1E2E3E4E5E6E7, 0xB0B1B2B3B4B5B6B7}); +} + +TEST_CASE("A64: UZP{1,2}.S", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; + code.UZP1(V2.S2(), V0.S2(), V1.S2()); + code.UZP2(V3.S2(), V0.S2(), V1.S2()); + code.UZP1(V4.S4(), V0.S4(), V1.S4()); + code.UZP2(V5.S4(), V0.S4(), V1.S4()); + + jit.SetPC(0); + jit.SetVector(0, {0xF4F5F6F7'F0F1F2F3, 0xE4E5E6E7'E0E1E2E3}); + jit.SetVector(1, {0xA4A5A6A7'A0A1A2A3, 0xB4B5B6B7'B0B1B2B3}); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + REQUIRE(jit.GetVector(2) == Vector{0xA0A1A2A3'F0F1F2F3, 0}); + REQUIRE(jit.GetVector(3) == Vector{0xA4A5A6A7'F4F5F6F7, 0}); + REQUIRE(jit.GetVector(4) == Vector{0xE0E1E2E3'F0F1F2F3, 0xB0B1B2B3'A0A1A2A3}); + REQUIRE(jit.GetVector(5) == Vector{0xE4E5E6E7'F4F5F6F7, 0xB4B5B6B7'A4A5A6A7}); +} + +TEST_CASE("A64: UZP{1,2}.H", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; + code.UZP1(V2.H4(), V0.H4(), V1.H4()); + code.UZP2(V3.H4(), V0.H4(), V1.H4()); + code.UZP1(V4.H8(), V0.H8(), V1.H8()); + code.UZP2(V5.H8(), V0.H8(), V1.H8()); + + jit.SetPC(0); + jit.SetVector(0, {0xF6F7'F4F5'F2F3'F0F1, 0xE6E7'E4E5'E2E3'E0E1}); + jit.SetVector(1, {0xA6A7'A4A5'A2A3'A0A1, 0xB6B7'B4B5'B2B3'B0B1}); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + REQUIRE(jit.GetVector(2) == Vector{0xA4A5'A0A1'F4F5'F0F1, 0}); + REQUIRE(jit.GetVector(3) == Vector{0xA6A7'A2A3'F6F7'F2F3, 0}); + REQUIRE(jit.GetVector(4) == Vector{0xE4E5'E0E1'F4F5'F0F1, 0xB4B5'B0B1'A4A5'A0A1}); + REQUIRE(jit.GetVector(5) == Vector{0xE6E7'E2E3'F6F7'F2F3, 0xB6B7'B2B3'A6A7'A2A3}); +} + +TEST_CASE("A64: UZP{1,2}.B", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; + code.UZP1(V2.B8(), V0.B8(), V1.B8()); + code.UZP2(V3.B8(), V0.B8(), V1.B8()); + code.UZP1(V4.B16(), V0.B16(), V1.B16()); + code.UZP2(V5.B16(), V0.B16(), V1.B16()); + + jit.SetPC(0); + jit.SetVector(0, {0xF7'F6'F5'F4'F3'F2'F1'F0, 0xE7'E6'E5'E4'E3'E2'E1'E0}); + jit.SetVector(1, {0xA7'A6'A5'A4'A3'A2'A1'A0, 0xB7'B6'B5'B4'B3'B2'B1'B0}); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + REQUIRE(jit.GetVector(2) == Vector{0xA6'A4'A2'A0'F6'F4'F2'F0, 0}); + REQUIRE(jit.GetVector(3) == Vector{0xA7'A5'A3'A1'F7'F5'F3'F1, 0}); + REQUIRE(jit.GetVector(4) == Vector{0xE6'E4'E2'E0'F6'F4'F2'F0, 0xB6'B4'B2'B0'A6'A4'A2'A0}); + REQUIRE(jit.GetVector(5) == Vector{0xE7'E5'E3'E1'F7'F5'F3'F1, 0xB7'B5'B3'B1'A7'A5'A3'A1}); +} + +TEST_CASE("A64: {S,U}MINP.S, {S,U}MAXP.S", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; + code.SMINP(V2.S2(), V0.S2(), V1.S2()); + code.UMINP(V3.S2(), V0.S2(), V1.S2()); + code.SMINP(V4.S4(), V0.S4(), V1.S4()); + code.UMINP(V5.S4(), V0.S4(), V1.S4()); + code.SMAXP(V6.S2(), V0.S2(), V1.S2()); + code.UMAXP(V7.S2(), V0.S2(), V1.S2()); + code.SMAXP(V8.S4(), V0.S4(), V1.S4()); + code.UMAXP(V9.S4(), V0.S4(), V1.S4()); + + constexpr std::array<Vector, 12> vectors = { + // initial input vectors [0-1] + Vector{0x00000003'00000002, 0xF1234567'01234567}, + Vector{0x80000000'7FFFFFFF, 0x76543210'76543209}, + // expected output vectors [2-9] + Vector{0x80000000'00000002, 0}, + Vector{0x7FFFFFFF'00000002, 0}, + Vector{0xF1234567'00000002, 0x76543209'80000000}, + Vector{0x01234567'00000002, 0x76543209'7FFFFFFF}, + Vector{0x7FFFFFFF'00000003, 0}, + Vector{0x80000000'00000003, 0}, + Vector{0x01234567'00000003, 0x76543210'7FFFFFFF}, + Vector{0xF1234567'00000003, 0x76543210'80000000}, + // input vectors with elements swapped pairwise [10-11] + Vector{0x00000002'00000003, 0x01234567'F1234567}, + Vector{0x7FFFFFFF'80000000, 0x76543209'76543210}, + }; + + jit.SetPC(0); + jit.SetVector(0, vectors[0]); + jit.SetVector(1, vectors[1]); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + CHECK(jit.GetVector(2) == vectors[2]); + CHECK(jit.GetVector(3) == vectors[3]); + CHECK(jit.GetVector(4) == vectors[4]); + CHECK(jit.GetVector(5) == vectors[5]); + CHECK(jit.GetVector(6) == vectors[6]); + CHECK(jit.GetVector(7) == vectors[7]); + CHECK(jit.GetVector(8) == vectors[8]); + CHECK(jit.GetVector(9) == vectors[9]); + + // run the same tests again but with the input vectors swapped pairwise, + // to ensure we aren't randomly producing the correct values + jit.SetPC(0); + jit.SetVectors(std::array<Vector, 32>{}); + jit.SetVector(0, vectors[10]); + jit.SetVector(1, vectors[11]); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + CHECK(jit.GetVector(2) == vectors[2]); + CHECK(jit.GetVector(3) == vectors[3]); + CHECK(jit.GetVector(4) == vectors[4]); + CHECK(jit.GetVector(5) == vectors[5]); + CHECK(jit.GetVector(6) == vectors[6]); + CHECK(jit.GetVector(7) == vectors[7]); + CHECK(jit.GetVector(8) == vectors[8]); + CHECK(jit.GetVector(9) == vectors[9]); +} + +TEST_CASE("A64: {S,U}MINP.H, {S,U}MAXP.H", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; + code.SMINP(V2.H4(), V0.H4(), V1.H4()); + code.UMINP(V3.H4(), V0.H4(), V1.H4()); + code.SMINP(V4.H8(), V0.H8(), V1.H8()); + code.UMINP(V5.H8(), V0.H8(), V1.H8()); + code.SMAXP(V6.H4(), V0.H4(), V1.H4()); + code.UMAXP(V7.H4(), V0.H4(), V1.H4()); + code.SMAXP(V8.H8(), V0.H8(), V1.H8()); + code.UMAXP(V9.H8(), V0.H8(), V1.H8()); + + constexpr std::array<Vector, 12> vectors = { + // initial input vectors [0-1] + Vector{0x0003'0002'7FFF'7FFE, 0xF123'0123'FFFF'0000}, + Vector{0x8000'7FFF'FFFF'FFFE, 0x8765'8764'0123'0124}, + // expected output vectors [2-9] + Vector{0x8000'FFFE'0002'7FFE, 0}, + Vector{0x7FFF'FFFE'0002'7FFE, 0}, + Vector{0xF123'FFFF'0002'7FFE, 0x8764'0123'8000'FFFE}, + Vector{0x0123'0000'0002'7FFE, 0x8764'0123'7FFF'FFFE}, + Vector{0x7FFF'FFFF'0003'7FFF, 0}, + Vector{0x8000'FFFF'0003'7FFF, 0}, + Vector{0x0123'0000'0003'7FFF, 0x8765'0124'7FFF'FFFF}, + Vector{0xF123'FFFF'0003'7FFF, 0x8765'0124'8000'FFFF}, + // input vectors with elements swapped pairwise [10-11] + Vector{0x0002'0003'7FFE'7FFF, 0x0123'F123'0000'FFFF}, + Vector{0x7FFF'8000'FFFE'FFFF, 0x8764'8765'0124'0123}, + }; + + jit.SetPC(0); + jit.SetVector(0, vectors[0]); + jit.SetVector(1, vectors[1]); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + CHECK(jit.GetVector(2) == vectors[2]); + CHECK(jit.GetVector(3) == vectors[3]); + CHECK(jit.GetVector(4) == vectors[4]); + CHECK(jit.GetVector(5) == vectors[5]); + CHECK(jit.GetVector(6) == vectors[6]); + CHECK(jit.GetVector(7) == vectors[7]); + CHECK(jit.GetVector(8) == vectors[8]); + CHECK(jit.GetVector(9) == vectors[9]); + + // run the same tests again but with the input vectors swapped pairwise, + // to ensure we aren't randomly producing the correct values + jit.SetPC(0); + jit.SetVectors(std::array<Vector, 32>{}); + jit.SetVector(0, vectors[10]); + jit.SetVector(1, vectors[11]); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + CHECK(jit.GetVector(2) == vectors[2]); + CHECK(jit.GetVector(3) == vectors[3]); + CHECK(jit.GetVector(4) == vectors[4]); + CHECK(jit.GetVector(5) == vectors[5]); + CHECK(jit.GetVector(6) == vectors[6]); + CHECK(jit.GetVector(7) == vectors[7]); + CHECK(jit.GetVector(8) == vectors[8]); + CHECK(jit.GetVector(9) == vectors[9]); +} + +TEST_CASE("A64: {S,U}MINP.B, {S,U}MAXP.B", "[a64]") { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; + code.SMINP(V2.B8(), V0.B8(), V1.B8()); + code.UMINP(V3.B8(), V0.B8(), V1.B8()); + code.SMINP(V4.B16(), V0.B16(), V1.B16()); + code.UMINP(V5.B16(), V0.B16(), V1.B16()); + code.SMAXP(V6.B8(), V0.B8(), V1.B8()); + code.UMAXP(V7.B8(), V0.B8(), V1.B8()); + code.SMAXP(V8.B16(), V0.B16(), V1.B16()); + code.UMAXP(V9.B16(), V0.B16(), V1.B16()); + + constexpr std::array<Vector, 12> vectors = { + // initial input vectors [0-1] + Vector{0x02'03'7F'7E'80'7F'FF'FE, 0x40'41'70'71'F0'F1'A0'A1}, + Vector{0xFF'00'81'18'99'9A'12'34, 0xC3'C2'B1'B0'82'7E'81'7F}, + // expected output vectors [2-9] + Vector{0xFF'81'99'12'02'7E'80'FE, 0}, + Vector{0x00'18'99'12'02'7E'7F'FE, 0}, + Vector{0x40'70'F0'A0'02'7E'80'FE, 0xC2'B0'82'81'FF'81'99'12}, + Vector{0x40'70'F0'A0'02'7E'7F'FE, 0xC2'B0'7E'7F'00'18'99'12}, + Vector{0x00'18'9A'34'03'7F'7F'FF, 0}, + Vector{0xFF'81'9A'34'03'7F'80'FF, 0}, + Vector{0x41'71'F1'A1'03'7F'7F'FF, 0xC3'B1'7E'7F'00'18'9A'34}, + Vector{0x41'71'F1'A1'03'7F'80'FF, 0xC3'B1'82'81'FF'81'9A'34}, + // input vectors with elements swapped pairwise [10-11] + Vector{0x03'02'7E'7F'7F'80'FE'FF, 0x41'40'71'70'F1'F0'A1'A0}, + Vector{0x00'FF'18'81'9A'99'34'12, 0xC2'C3'B0'B1'7E'82'7F'81}, + }; + + jit.SetPC(0); + jit.SetVector(0, vectors[0]); + jit.SetVector(1, vectors[1]); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + CHECK(jit.GetVector(2) == vectors[2]); + CHECK(jit.GetVector(3) == vectors[3]); + + CHECK(jit.GetVector(4) == vectors[4]); + CHECK(jit.GetVector(5) == vectors[5]); + + CHECK(jit.GetVector(6) == vectors[6]); + CHECK(jit.GetVector(7) == vectors[7]); + + CHECK(jit.GetVector(8) == vectors[8]); + CHECK(jit.GetVector(9) == vectors[9]); + + // run the same tests again but with the input vectors swapped pairwise, + // to ensure we aren't randomly producing the correct values + jit.SetPC(0); + jit.SetVectors(std::array<Vector, 32>{}); + jit.SetVector(0, vectors[10]); + jit.SetVector(1, vectors[11]); + + env.ticks_left = env.code_mem.size(); + jit.Run(); + + CHECK(jit.GetVector(2) == vectors[2]); + CHECK(jit.GetVector(3) == vectors[3]); + + CHECK(jit.GetVector(4) == vectors[4]); + CHECK(jit.GetVector(5) == vectors[5]); + + CHECK(jit.GetVector(6) == vectors[6]); + CHECK(jit.GetVector(7) == vectors[7]); + + CHECK(jit.GetVector(8) == vectors[8]); + CHECK(jit.GetVector(9) == vectors[9]); +} diff --git a/externals/dynarmic/tests/A64/fibonacci.cpp b/externals/dynarmic/tests/A64/fibonacci.cpp new file mode 100644 index 0000000000..29dcbdcd72 --- /dev/null +++ b/externals/dynarmic/tests/A64/fibonacci.cpp @@ -0,0 +1,168 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2023 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <array> +#include <exception> +#include <map> + +#include <catch2/catch_test_macros.hpp> +#include <mcl/stdint.hpp> +#include <oaknut/oaknut.hpp> + +#include "dynarmic/interface/A64/a64.h" + +using namespace Dynarmic; + +namespace { + +class MyEnvironment final : public A64::UserCallbacks { +public: + u64 ticks_left = 0; + std::map<u64, u8> memory{}; + + u8 MemoryRead8(u64 vaddr) override { + return memory[vaddr]; + } + + u16 MemoryRead16(u64 vaddr) override { + return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8; + } + + u32 MemoryRead32(u64 vaddr) override { + return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16; + } + + u64 MemoryRead64(u64 vaddr) override { + return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32; + } + + std::array<u64, 2> MemoryRead128(u64 vaddr) override { + return {MemoryRead64(vaddr), MemoryRead64(vaddr + 8)}; + } + + void MemoryWrite8(u64 vaddr, u8 value) override { + memory[vaddr] = value; + } + + void MemoryWrite16(u64 vaddr, u16 value) override { + MemoryWrite8(vaddr, u8(value)); + MemoryWrite8(vaddr + 1, u8(value >> 8)); + } + + void MemoryWrite32(u64 vaddr, u32 value) override { + MemoryWrite16(vaddr, u16(value)); + MemoryWrite16(vaddr + 2, u16(value >> 16)); + } + + void MemoryWrite64(u64 vaddr, u64 value) override { + MemoryWrite32(vaddr, u32(value)); + MemoryWrite32(vaddr + 4, u32(value >> 32)); + } + + void MemoryWrite128(u64 vaddr, std::array<u64, 2> value) override { + MemoryWrite64(vaddr, value[0]); + MemoryWrite64(vaddr + 8, value[1]); + } + + void InterpreterFallback(u64, size_t) override { + // This is never called in practice. + std::terminate(); + } + + void CallSVC(u32) override { + // Do something. + } + + void ExceptionRaised(u64, A64::Exception) override { + cpu->HaltExecution(); + } + + void AddTicks(u64) override { + } + + u64 GetTicksRemaining() override { + return 1000000000000; + } + + std::uint64_t GetCNTPCT() override { + return 0; + } + + A64::Jit* cpu; +}; + +} // namespace + +TEST_CASE("A64: fibonacci", "[a64]") { + MyEnvironment env; + A64::UserConfig user_config; + user_config.callbacks = &env; + A64::Jit cpu{user_config}; + env.cpu = &cpu; + + std::vector<u32> instructions(1024); + oaknut::CodeGenerator code{instructions.data(), nullptr}; + + using namespace oaknut::util; + + oaknut::Label start, end, zero, recurse; + + code.l(start); + code.STP(X29, X30, SP, PRE_INDEXED, -32); + code.STP(X20, X19, SP, 16); + code.MOV(X29, SP); + code.MOV(W19, W0); + code.SUBS(W0, W0, 1); + code.B(LT, zero); + code.B(NE, recurse); + code.MOV(W0, 1); + code.B(end); + + code.l(zero); + code.MOV(W0, WZR); + code.B(end); + + code.l(recurse); + code.BL(start); + code.MOV(W20, W0); + code.SUB(W0, W19, 2); + code.BL(start); + code.ADD(W0, W0, W20); + + code.l(end); + code.LDP(X20, X19, SP, 16); + code.LDP(X29, X30, SP, POST_INDEXED, 32); + code.RET(); + + for (size_t i = 0; i < 1024; i++) { + env.MemoryWrite32(i * 4, instructions[i]); + } + env.MemoryWrite32(8888, 0xd4200000); + cpu.SetRegister(30, 8888); + + cpu.SetRegister(0, 10); + cpu.SetSP(0xffff0000); + cpu.SetPC(0); + + cpu.Run(); + + REQUIRE(cpu.GetRegister(0) == 55); + + cpu.SetRegister(0, 20); + cpu.SetSP(0xffff0000); + cpu.SetPC(0); + + cpu.Run(); + + REQUIRE(cpu.GetRegister(0) == 6765); + + cpu.SetRegister(0, 30); + cpu.SetSP(0xffff0000); + cpu.SetPC(0); + + cpu.Run(); + + REQUIRE(cpu.GetRegister(0) == 832040); +} diff --git a/externals/dynarmic/tests/A64/fp_min_max.cpp b/externals/dynarmic/tests/A64/fp_min_max.cpp new file mode 100644 index 0000000000..7aa1ef4407 --- /dev/null +++ b/externals/dynarmic/tests/A64/fp_min_max.cpp @@ -0,0 +1,185 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2022 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <vector> + +#include <catch2/catch_test_macros.hpp> +#include <mcl/stdint.hpp> + +#include "./testenv.h" + +using namespace Dynarmic; + +namespace { + +struct TestCase { + u32 a; + u32 b; + u32 fmax; + u32 fmaxnm; + u32 fmin; + u32 fminnm; +}; + +const std::vector test_cases{ + // a b fmax fmaxnm fmin fminnm + TestCase{0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000}, // +0.0 + TestCase{0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000}, // -0.0 + TestCase{0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000}, // +1.0 + TestCase{0xbf800000, 0xbf800000, 0xbf800000, 0xbf800000, 0xbf800000, 0xbf800000}, // -1.0 + TestCase{0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000}, // +Inf + TestCase{0xff800000, 0xff800000, 0xff800000, 0xff800000, 0xff800000, 0xff800000}, // -Inf + TestCase{0x7fc00041, 0x7fc00041, 0x7fc00041, 0x7fc00041, 0x7fc00041, 0x7fc00041}, // QNaN + TestCase{0x7f800042, 0x7f800042, 0x7fc00042, 0x7fc00042, 0x7fc00042, 0x7fc00042}, // SNaN + TestCase{0x00000000, 0x80000000, 0x00000000, 0x00000000, 0x80000000, 0x80000000}, // (+0.0, -0.0) + TestCase{0x3f800000, 0xbf800000, 0x3f800000, 0x3f800000, 0xbf800000, 0xbf800000}, // (+1.0, -1.0) + TestCase{0x3f800000, 0x7f800000, 0x7f800000, 0x7f800000, 0x3f800000, 0x3f800000}, // (+1.0, +Inf) + TestCase{0x3f800000, 0xff800000, 0x3f800000, 0x3f800000, 0xff800000, 0xff800000}, // (+1.0, -Inf) + TestCase{0x7f800000, 0xff800000, 0x7f800000, 0x7f800000, 0xff800000, 0xff800000}, // (+Inf, -Inf) + TestCase{0x3f800000, 0x7fc00041, 0x7fc00041, 0x3f800000, 0x7fc00041, 0x3f800000}, // (+1.0, QNaN) + TestCase{0x3f800000, 0x7f800042, 0x7fc00042, 0x7fc00042, 0x7fc00042, 0x7fc00042}, // (+1.0, SNaN) + TestCase{0x7f800000, 0x7fc00041, 0x7fc00041, 0x7f800000, 0x7fc00041, 0x7f800000}, // (+Inf, QNaN) + TestCase{0x7f800000, 0x7f800042, 0x7fc00042, 0x7fc00042, 0x7fc00042, 0x7fc00042}, // (+Inf, SNaN) + TestCase{0x7fc00041, 0x7f800042, 0x7fc00042, 0x7fc00042, 0x7fc00042, 0x7fc00042}, // (QNaN, SNaN) + TestCase{0xffa57454, 0xe343a6b3, 0xffe57454, 0xffe57454, 0xffe57454, 0xffe57454}, +}; + +const std::vector unidirectional_test_cases{ + TestCase{0x7fc00041, 0x7fc00043, 0x7fc00041, 0x7fc00041, 0x7fc00041, 0x7fc00041}, // (QNaN, QNaN) + TestCase{0x7f800042, 0x7f800044, 0x7fc00042, 0x7fc00042, 0x7fc00042, 0x7fc00042}, // (SNaN, SNaN) +}; + +constexpr u32 default_nan = 0x7fc00000; + +bool is_nan(u32 value) { + return (value & 0x7f800000) == 0x7f800000 && (value & 0x007fffff) != 0; +} + +u32 force_default_nan(u32 value) { + return is_nan(value) ? default_nan : value; +} + +template<typename Fn> +void run_test(u32 instruction, Fn fn) { + A64TestEnv env; + A64::Jit jit{A64::UserConfig{&env}}; + + env.code_mem.emplace_back(instruction); // FMAX S0, S1, S2 + env.code_mem.emplace_back(0x14000000); // B . + + for (const auto base_fpcr : {0, 0x01000000}) { + for (const auto test_case : test_cases) { + INFO(test_case.a); + INFO(test_case.b); + + jit.SetFpcr(base_fpcr); + + jit.SetVector(0, {42, 0}); + jit.SetVector(1, {test_case.a, 0}); + jit.SetVector(2, {test_case.b, 0}); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0)[0] == fn(test_case)); + + jit.SetVector(0, {42, 0}); + jit.SetVector(1, {test_case.b, 0}); + jit.SetVector(2, {test_case.a, 0}); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0)[0] == fn(test_case)); + + jit.SetFpcr(base_fpcr | 0x02000000); + + jit.SetVector(0, {42, 0}); + jit.SetVector(1, {test_case.a, 0}); + jit.SetVector(2, {test_case.b, 0}); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0)[0] == force_default_nan(fn(test_case))); + + jit.SetVector(0, {42, 0}); + jit.SetVector(1, {test_case.b, 0}); + jit.SetVector(2, {test_case.a, 0}); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0)[0] == force_default_nan(fn(test_case))); + } + + for (const auto test_case : unidirectional_test_cases) { + INFO(test_case.a); + INFO(test_case.b); + + jit.SetFpcr(base_fpcr); + + jit.SetVector(0, {42, 0}); + jit.SetVector(1, {test_case.a, 0}); + jit.SetVector(2, {test_case.b, 0}); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0)[0] == fn(test_case)); + + jit.SetFpcr(base_fpcr | 0x02000000); + + jit.SetVector(0, {42, 0}); + jit.SetVector(1, {test_case.a, 0}); + jit.SetVector(2, {test_case.b, 0}); + jit.SetPC(0); + + env.ticks_left = 2; + jit.Run(); + + REQUIRE(jit.GetVector(0)[0] == force_default_nan(fn(test_case))); + } + } +} + +} // namespace + +TEST_CASE("A64: FMAX (scalar)", "[a64]") { + run_test(0x1e224820, [](const TestCase& test_case) { return test_case.fmax; }); +} + +TEST_CASE("A64: FMIN (scalar)", "[a64]") { + run_test(0x1e225820, [](const TestCase& test_case) { return test_case.fmin; }); +} + +TEST_CASE("A64: FMAXNM (scalar)", "[a64]") { + run_test(0x1e226820, [](const TestCase& test_case) { return test_case.fmaxnm; }); +} + +TEST_CASE("A64: FMINNM (scalar)", "[a64]") { + run_test(0x1e227820, [](const TestCase& test_case) { return test_case.fminnm; }); +} + +TEST_CASE("A64: FMAX (vector)", "[a64]") { + run_test(0x4e22f420, [](const TestCase& test_case) { return test_case.fmax; }); +} + +TEST_CASE("A64: FMIN (vector)", "[a64]") { + run_test(0x4ea2f420, [](const TestCase& test_case) { return test_case.fmin; }); +} + +TEST_CASE("A64: FMAXNM (vector)", "[a64]") { + run_test(0x4e22c420, [](const TestCase& test_case) { return test_case.fmaxnm; }); +} + +TEST_CASE("A64: FMINNM (vector)", "[a64]") { + run_test(0x4ea2c420, [](const TestCase& test_case) { return test_case.fminnm; }); +} diff --git a/externals/dynarmic/tests/A64/fuzz_with_unicorn.cpp b/externals/dynarmic/tests/A64/fuzz_with_unicorn.cpp new file mode 100644 index 0000000000..1a56a982ef --- /dev/null +++ b/externals/dynarmic/tests/A64/fuzz_with_unicorn.cpp @@ -0,0 +1,519 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <algorithm> +#include <cstring> +#include <string> +#include <vector> + +#include <catch2/catch_test_macros.hpp> +#include <mcl/scope_exit.hpp> +#include <mcl/stdint.hpp> + +#include "../fuzz_util.h" +#include "../rand_int.h" +#include "../unicorn_emu/a64_unicorn.h" +#include "./testenv.h" +#include "dynarmic/common/fp/fpcr.h" +#include "dynarmic/common/fp/fpsr.h" +#include "dynarmic/common/llvm_disassemble.h" +#include "dynarmic/frontend/A64/a64_location_descriptor.h" +#include "dynarmic/frontend/A64/a64_types.h" +#include "dynarmic/frontend/A64/decoder/a64.h" +#include "dynarmic/frontend/A64/translate/a64_translate.h" +#include "dynarmic/ir/basic_block.h" +#include "dynarmic/ir/opcodes.h" +#include "dynarmic/ir/opt/passes.h" + +// Must be declared last for all necessary operator<< to be declared prior to this. +#include <fmt/format.h> +#include <fmt/ostream.h> + +using namespace Dynarmic; + +static bool ShouldTestInst(u32 instruction, u64 pc, bool is_last_inst) { + const A64::LocationDescriptor location{pc, {}}; + IR::Block block{location}; + bool should_continue = A64::TranslateSingleInstruction(block, location, instruction); + if (!should_continue && !is_last_inst) + return false; + if (auto terminal = block.GetTerminal(); boost::get<IR::Term::Interpret>(&terminal)) + return false; + for (const auto& ir_inst : block) { + switch (ir_inst.GetOpcode()) { + case IR::Opcode::A64ExceptionRaised: + case IR::Opcode::A64CallSupervisor: + case IR::Opcode::A64DataCacheOperationRaised: + case IR::Opcode::A64GetCNTPCT: + return false; + default: + continue; + } + } + return true; +} + +static u32 GenRandomInst(u64 pc, bool is_last_inst) { + static const struct InstructionGeneratorInfo { + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + } instructions = [] { + const std::vector<std::tuple<std::string, const char*>> list{ +#define INST(fn, name, bitstring) {#fn, bitstring}, +#include "dynarmic/frontend/A64/decoder/a64.inc" +#undef INST + }; + + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + + // List of instructions not to test + const std::vector<std::string> do_not_test{ + // Unimplemented in QEMU + "STLLR", + // Unimplemented in QEMU + "LDLAR", + // Dynarmic and QEMU currently differ on how the exclusive monitor's address range works. + "STXR", + "STLXR", + "STXP", + "STLXP", + "LDXR", + "LDAXR", + "LDXP", + "LDAXP", + // Behaviour differs from QEMU + "MSR_reg", + "MSR_imm", + "MRS", + }; + + for (const auto& [fn, bitstring] : list) { + if (fn == "UnallocatedEncoding") { + continue; + } + if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + invalid.emplace_back(InstructionGenerator{bitstring}); + continue; + } + generators.emplace_back(InstructionGenerator{bitstring}); + } + return InstructionGeneratorInfo{generators, invalid}; + }(); + + while (true) { + const size_t index = RandInt<size_t>(0, instructions.generators.size() - 1); + const u32 inst = instructions.generators[index].Generate(); + + if (std::any_of(instructions.invalid.begin(), instructions.invalid.end(), [inst](const auto& invalid) { return invalid.Match(inst); })) { + continue; + } + if (ShouldTestInst(inst, pc, is_last_inst)) { + return inst; + } + } +} + +static u32 GenFloatInst(u64 pc, bool is_last_inst) { + static const std::vector<InstructionGenerator> instruction_generators = [] { + const std::vector<std::tuple<std::string, std::string, const char*>> list{ +#define INST(fn, name, bitstring) {#fn, #name, bitstring}, +#include "dynarmic/frontend/A64/decoder/a64.inc" +#undef INST + }; + + // List of instructions not to test + const std::vector<std::string> do_not_test{}; + + std::vector<InstructionGenerator> result; + + for (const auto& [fn, name, bitstring] : list) { + (void)name; + + if (fn[0] != 'F') { + continue; + } else if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + continue; + } + result.emplace_back(InstructionGenerator{bitstring}); + } + + return result; + }(); + + while (true) { + const size_t index = RandInt<size_t>(0, instruction_generators.size() - 1); + const u32 instruction = instruction_generators[index].Generate(); + + if (ShouldTestInst(instruction, pc, is_last_inst)) { + return instruction; + } + } +} + +static Dynarmic::A64::UserConfig GetUserConfig(A64TestEnv& jit_env) { + Dynarmic::A64::UserConfig jit_user_config{&jit_env}; + jit_user_config.optimizations &= ~OptimizationFlag::FastDispatch; + // The below corresponds to the settings for qemu's aarch64_max_initfn + jit_user_config.dczid_el0 = 7; + jit_user_config.ctr_el0 = 0x80038003; + return jit_user_config; +} + +static void RunTestInstance(Dynarmic::A64::Jit& jit, A64Unicorn& uni, A64TestEnv& jit_env, A64TestEnv& uni_env, const A64Unicorn::RegisterArray& regs, const A64Unicorn::VectorArray& vecs, const size_t instructions_start, const std::vector<u32>& instructions, const u32 pstate, const u32 fpcr) { + jit_env.code_mem = instructions; + uni_env.code_mem = instructions; + jit_env.code_mem.emplace_back(0x14000000); // B . + uni_env.code_mem.emplace_back(0x14000000); // B . + jit_env.code_mem_start_address = instructions_start; + uni_env.code_mem_start_address = instructions_start; + jit_env.modified_memory.clear(); + uni_env.modified_memory.clear(); + jit_env.interrupts.clear(); + uni_env.interrupts.clear(); + + const u64 initial_sp = RandInt<u64>(0x30'0000'0000, 0x40'0000'0000) * 4; + + jit.SetRegisters(regs); + jit.SetVectors(vecs); + jit.SetPC(instructions_start); + jit.SetSP(initial_sp); + jit.SetFpcr(fpcr); + jit.SetFpsr(0); + jit.SetPstate(pstate); + jit.ClearCache(); + uni.SetRegisters(regs); + uni.SetVectors(vecs); + uni.SetPC(instructions_start); + uni.SetSP(initial_sp); + uni.SetFpcr(fpcr); + uni.SetFpsr(0); + uni.SetPstate(pstate); + uni.ClearPageCache(); + + jit_env.ticks_left = instructions.size(); + jit.Run(); + + uni_env.ticks_left = instructions.size(); + uni.Run(); + + SCOPE_FAIL { + fmt::print("Instruction Listing:\n"); + for (u32 instruction : instructions) { + fmt::print("{:08x} {}\n", instruction, Common::DisassembleAArch64(instruction)); + } + fmt::print("\n"); + + fmt::print("Initial register listing:\n"); + for (size_t i = 0; i < regs.size(); ++i) { + fmt::print("{:3s}: {:016x}\n", A64::RegToString(static_cast<A64::Reg>(i)), regs[i]); + } + for (size_t i = 0; i < vecs.size(); ++i) { + fmt::print("{:3s}: {:016x}{:016x}\n", A64::VecToString(static_cast<A64::Vec>(i)), vecs[i][1], vecs[i][0]); + } + fmt::print("sp : {:016x}\n", initial_sp); + fmt::print("pc : {:016x}\n", instructions_start); + fmt::print("p : {:08x}\n", pstate); + fmt::print("fpcr {:08x}\n", fpcr); + fmt::print("fpcr.AHP {}\n", FP::FPCR{fpcr}.AHP()); + fmt::print("fpcr.DN {}\n", FP::FPCR{fpcr}.DN()); + fmt::print("fpcr.FZ {}\n", FP::FPCR{fpcr}.FZ()); + fmt::print("fpcr.RMode {}\n", static_cast<size_t>(FP::FPCR{fpcr}.RMode())); + fmt::print("fpcr.FZ16 {}\n", FP::FPCR{fpcr}.FZ16()); + fmt::print("\n"); + + fmt::print("Final register listing:\n"); + fmt::print(" unicorn dynarmic\n"); + const auto uni_regs = uni.GetRegisters(); + for (size_t i = 0; i < regs.size(); ++i) { + fmt::print("{:3s}: {:016x} {:016x} {}\n", A64::RegToString(static_cast<A64::Reg>(i)), uni_regs[i], jit.GetRegisters()[i], uni_regs[i] != jit.GetRegisters()[i] ? "*" : ""); + } + const auto uni_vecs = uni.GetVectors(); + for (size_t i = 0; i < vecs.size(); ++i) { + fmt::print("{:3s}: {:016x}{:016x} {:016x}{:016x} {}\n", A64::VecToString(static_cast<A64::Vec>(i)), + uni_vecs[i][1], uni_vecs[i][0], + jit.GetVectors()[i][1], jit.GetVectors()[i][0], + uni_vecs[i] != jit.GetVectors()[i] ? "*" : ""); + } + fmt::print("sp : {:016x} {:016x} {}\n", uni.GetSP(), jit.GetSP(), uni.GetSP() != jit.GetSP() ? "*" : ""); + fmt::print("pc : {:016x} {:016x} {}\n", uni.GetPC(), jit.GetPC(), uni.GetPC() != jit.GetPC() ? "*" : ""); + fmt::print("p : {:08x} {:08x} {}\n", uni.GetPstate(), jit.GetPstate(), (uni.GetPstate() & 0xF0000000) != (jit.GetPstate() & 0xF0000000) ? "*" : ""); + fmt::print("qc : {:08x} {:08x} {}\n", uni.GetFpsr(), jit.GetFpsr(), FP::FPSR{uni.GetFpsr()}.QC() != FP::FPSR{jit.GetFpsr()}.QC() ? "*" : ""); + fmt::print("\n"); + + fmt::print("Modified memory:\n"); + fmt::print(" uni dyn\n"); + auto uni_iter = uni_env.modified_memory.begin(); + auto jit_iter = jit_env.modified_memory.begin(); + while (uni_iter != uni_env.modified_memory.end() || jit_iter != jit_env.modified_memory.end()) { + if (uni_iter == uni_env.modified_memory.end() || (jit_iter != jit_env.modified_memory.end() && uni_iter->first > jit_iter->first)) { + fmt::print("{:016x}: {:02x} *\n", jit_iter->first, jit_iter->second); + jit_iter++; + } else if (jit_iter == jit_env.modified_memory.end() || jit_iter->first > uni_iter->first) { + fmt::print("{:016x}: {:02x} *\n", uni_iter->first, uni_iter->second); + uni_iter++; + } else if (uni_iter->first == jit_iter->first) { + fmt::print("{:016x}: {:02x} {:02x} {}\n", uni_iter->first, uni_iter->second, jit_iter->second, uni_iter->second != jit_iter->second ? "*" : ""); + uni_iter++; + jit_iter++; + } + } + fmt::print("\n"); + + const auto get_code = [&jit_env](u64 vaddr) { return jit_env.MemoryReadCode(vaddr); }; + IR::Block ir_block = A64::Translate({instructions_start, FP::FPCR{fpcr}}, get_code, {}); + Optimization::A64CallbackConfigPass(ir_block, GetUserConfig(jit_env)); + Optimization::NamingPass(ir_block); + + fmt::print("IR:\n"); + fmt::print("{}\n", IR::DumpBlock(ir_block)); + + Optimization::A64GetSetElimination(ir_block); + Optimization::DeadCodeElimination(ir_block); + Optimization::ConstantPropagation(ir_block); + Optimization::DeadCodeElimination(ir_block); + + fmt::print("Optimized IR:\n"); + fmt::print("{}\n", IR::DumpBlock(ir_block)); + + fmt::print("x86_64:\n"); + jit.DumpDisassembly(); + + fmt::print("Interrupts:\n"); + for (auto& i : uni_env.interrupts) { + puts(i.c_str()); + } + }; + + REQUIRE(uni_env.code_mem_modified_by_guest == jit_env.code_mem_modified_by_guest); + if (uni_env.code_mem_modified_by_guest) { + return; + } + + REQUIRE(uni.GetPC() == jit.GetPC()); + REQUIRE(uni.GetRegisters() == jit.GetRegisters()); + REQUIRE(uni.GetVectors() == jit.GetVectors()); + REQUIRE(uni.GetSP() == jit.GetSP()); + REQUIRE((uni.GetPstate() & 0xF0000000) == (jit.GetPstate() & 0xF0000000)); + REQUIRE(uni_env.modified_memory == jit_env.modified_memory); + REQUIRE(uni_env.interrupts.empty()); + REQUIRE(FP::FPSR{uni.GetFpsr()}.QC() == FP::FPSR{jit.GetFpsr()}.QC()); +} + +TEST_CASE("A64: Single random instruction", "[a64]") { + A64TestEnv jit_env{}; + A64TestEnv uni_env{}; + + Dynarmic::A64::Jit jit{GetUserConfig(jit_env)}; + A64Unicorn uni{uni_env}; + + A64Unicorn::RegisterArray regs; + A64Unicorn::VectorArray vecs; + std::vector<u32> instructions(1); + + for (size_t iteration = 0; iteration < 100000; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u64>(0, ~u64(0)); }); + std::generate(vecs.begin(), vecs.end(), RandomVector); + + instructions[0] = GenRandomInst(0, true); + + const u64 start_address = RandInt<u64>(0, 0x10'0000'0000) * 4; + const u32 pstate = RandInt<u32>(0, 0xF) << 28; + const u32 fpcr = RandomFpcr(); + + INFO("Instruction: 0x" << std::hex << instructions[0]); + + RunTestInstance(jit, uni, jit_env, uni_env, regs, vecs, start_address, instructions, pstate, fpcr); + } +} + +TEST_CASE("A64: Floating point instructions", "[a64]") { + A64TestEnv jit_env{}; + A64TestEnv uni_env{}; + + Dynarmic::A64::Jit jit{GetUserConfig(jit_env)}; + A64Unicorn uni{uni_env}; + + static constexpr std::array<u64, 80> float_numbers{ + 0x00000000, // positive zero + 0x00000001, // smallest positive denormal + 0x00000076, // + 0x00002b94, // + 0x00636d24, // + 0x007fffff, // largest positive denormal + 0x00800000, // smallest positive normalised real + 0x00800002, // + 0x01398437, // + 0x0ba98d27, // + 0x0ba98d7a, // + 0x751f853a, // + 0x7f7ffff0, // + 0x7f7fffff, // largest positive normalised real + 0x7f800000, // positive infinity + 0x7f800001, // first positive SNaN + 0x7f984a37, // + 0x7fbfffff, // last positive SNaN + 0x7fc00000, // first positive QNaN + 0x7fd9ba98, // + 0x7fffffff, // last positive QNaN + 0x80000000, // negative zero + 0x80000001, // smallest negative denormal + 0x80000076, // + 0x80002b94, // + 0x80636d24, // + 0x807fffff, // largest negative denormal + 0x80800000, // smallest negative normalised real + 0x80800002, // + 0x81398437, // + 0x8ba98d27, // + 0x8ba98d7a, // + 0xf51f853a, // + 0xff7ffff0, // + 0xff7fffff, // largest negative normalised real + 0xff800000, // negative infinity + 0xff800001, // first negative SNaN + 0xff984a37, // + 0xffbfffff, // last negative SNaN + 0xffc00000, // first negative QNaN + 0xffd9ba98, // + 0xffffffff, // last negative QNaN + // some random numbers follow + 0x4f3495cb, + 0xe73a5134, + 0x7c994e9e, + 0x6164bd6c, + 0x09503366, + 0xbf5a97c9, + 0xe6ff1a14, + 0x77f31e2f, + 0xaab4d7d8, + 0x0966320b, + 0xb26bddee, + 0xb5c8e5d3, + 0x317285d3, + 0x3c9623b1, + 0x51fd2c7c, + 0x7b906a6c, + 0x3f800000, + 0x3dcccccd, + 0x3f000000, + 0x42280000, + 0x3eaaaaab, + 0xc1200000, + 0xbf800000, + 0xbf8147ae, + 0x3f8147ae, + 0x415df525, + 0xc79b271e, + 0x460e8c84, + // some 64-bit-float upper-halves + 0x7ff00000, // +SNaN / +Inf + 0x7ff0abcd, // +SNaN + 0x7ff80000, // +QNaN + 0x7ff81234, // +QNaN + 0xfff00000, // -SNaN / -Inf + 0xfff05678, // -SNaN + 0xfff80000, // -QNaN + 0xfff809ef, // -QNaN + 0x3ff00000, // Number near +1.0 + 0xbff00000, // Number near -1.0 + }; + + const auto gen_float = [&] { + if (RandInt<size_t>(0, 1) == 0) { + return RandInt<u64>(0, 0xffffffff); + } + return float_numbers[RandInt<size_t>(0, float_numbers.size() - 1)]; + }; + + const auto gen_vector = [&] { + u64 upper = (gen_float() << 32) | gen_float(); + u64 lower = (gen_float() << 32) | gen_float(); + return Vector{lower, upper}; + }; + + A64Unicorn::RegisterArray regs; + A64Unicorn::VectorArray vecs; + std::vector<u32> instructions(1); + + for (size_t iteration = 0; iteration < 100000; ++iteration) { + std::generate(regs.begin(), regs.end(), gen_float); + std::generate(vecs.begin(), vecs.end(), gen_vector); + + instructions[0] = GenFloatInst(0, true); + + const u64 start_address = RandInt<u64>(0, 0x10'0000'0000) * 4; + const u32 pstate = RandInt<u32>(0, 0xF) << 28; + const u32 fpcr = RandomFpcr(); + + INFO("Instruction: 0x" << std::hex << instructions[0]); + + RunTestInstance(jit, uni, jit_env, uni_env, regs, vecs, start_address, instructions, pstate, fpcr); + } +} + +TEST_CASE("A64: Small random block", "[a64]") { + A64TestEnv jit_env{}; + A64TestEnv uni_env{}; + + Dynarmic::A64::Jit jit{GetUserConfig(jit_env)}; + A64Unicorn uni{uni_env}; + + A64Unicorn::RegisterArray regs; + A64Unicorn::VectorArray vecs; + std::vector<u32> instructions(5); + + for (size_t iteration = 0; iteration < 100000; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u64>(0, ~u64(0)); }); + std::generate(vecs.begin(), vecs.end(), RandomVector); + + instructions[0] = GenRandomInst(0, false); + instructions[1] = GenRandomInst(4, false); + instructions[2] = GenRandomInst(8, false); + instructions[3] = GenRandomInst(12, false); + instructions[4] = GenRandomInst(16, true); + + const u64 start_address = RandInt<u64>(0, 0x10'0000'0000) * 4; + const u32 pstate = RandInt<u32>(0, 0xF) << 28; + const u32 fpcr = RandomFpcr(); + + INFO("Instruction 1: 0x" << std::hex << instructions[0]); + INFO("Instruction 2: 0x" << std::hex << instructions[1]); + INFO("Instruction 3: 0x" << std::hex << instructions[2]); + INFO("Instruction 4: 0x" << std::hex << instructions[3]); + INFO("Instruction 5: 0x" << std::hex << instructions[4]); + + RunTestInstance(jit, uni, jit_env, uni_env, regs, vecs, start_address, instructions, pstate, fpcr); + } +} + +TEST_CASE("A64: Large random block", "[a64]") { + A64TestEnv jit_env{}; + A64TestEnv uni_env{}; + + Dynarmic::A64::Jit jit{GetUserConfig(jit_env)}; + A64Unicorn uni{uni_env}; + + A64Unicorn::RegisterArray regs; + A64Unicorn::VectorArray vecs; + + constexpr size_t instruction_count = 100; + std::vector<u32> instructions(instruction_count); + + for (size_t iteration = 0; iteration < 500; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u64>(0, ~u64(0)); }); + std::generate(vecs.begin(), vecs.end(), RandomVector); + + for (size_t j = 0; j < instruction_count; ++j) { + instructions[j] = GenRandomInst(j * 4, j == instruction_count - 1); + } + + const u64 start_address = RandInt<u64>(0, 0x10'0000'0000) * 4; + const u32 pstate = RandInt<u32>(0, 0xF) << 28; + const u32 fpcr = RandomFpcr(); + + RunTestInstance(jit, uni, jit_env, uni_env, regs, vecs, start_address, instructions, pstate, fpcr); + } +} diff --git a/externals/dynarmic/tests/A64/misaligned_page_table.cpp b/externals/dynarmic/tests/A64/misaligned_page_table.cpp new file mode 100644 index 0000000000..f54aa58641 --- /dev/null +++ b/externals/dynarmic/tests/A64/misaligned_page_table.cpp @@ -0,0 +1,29 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <catch2/catch_test_macros.hpp> + +#include "./testenv.h" +#include "dynarmic/interface/A64/a64.h" + +TEST_CASE("misaligned load/store do not use page_table when detect_misaligned_access_via_page_table is set", "[a64]") { + A64TestEnv env; + Dynarmic::A64::UserConfig conf{&env}; + conf.page_table = nullptr; + conf.detect_misaligned_access_via_page_table = 128; + conf.only_detect_misalignment_via_page_table_on_page_boundary = true; + Dynarmic::A64::Jit jit{conf}; + + env.code_mem.emplace_back(0x3c800400); // STR Q0, [X0], #0 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + jit.SetRegister(0, 0x000000000b0afff8); + + env.ticks_left = 2; + jit.Run(); + + // If we don't crash we're fine. +} diff --git a/externals/dynarmic/tests/A64/test_invalidation.cpp b/externals/dynarmic/tests/A64/test_invalidation.cpp new file mode 100644 index 0000000000..fa35b02b7f --- /dev/null +++ b/externals/dynarmic/tests/A64/test_invalidation.cpp @@ -0,0 +1,113 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <catch2/catch_test_macros.hpp> + +#include "./testenv.h" +#include "dynarmic/interface/A64/a64.h" + +using namespace Dynarmic; + +TEST_CASE("ensure fast dispatch entry is cleared even when a block does not have any patching requirements", "[a64]") { + A64TestEnv env; + + A64::UserConfig conf{&env}; + A64::Jit jit{conf}; + + REQUIRE(conf.HasOptimization(OptimizationFlag::FastDispatch)); + + env.code_mem_start_address = 100; + env.code_mem.clear(); + env.code_mem.emplace_back(0xd2800d80); // MOV X0, 108 + env.code_mem.emplace_back(0xd61f0000); // BR X0 + env.code_mem.emplace_back(0xd2800540); // MOV X0, 42 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(100); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 42); + + jit.SetPC(100); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 42); + + jit.InvalidateCacheRange(108, 4); + + jit.SetPC(100); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 42); + + env.code_mem[2] = 0xd28008a0; // MOV X0, 69 + + jit.SetPC(100); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 42); + + jit.InvalidateCacheRange(108, 4); + + jit.SetPC(100); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 69); + + jit.SetPC(100); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 69); +} + +TEST_CASE("ensure fast dispatch entry is cleared even when a block does not have any patching requirements 2", "[a64]") { + A64TestEnv env; + + A64::UserConfig conf{&env}; + A64::Jit jit{conf}; + + REQUIRE(conf.HasOptimization(OptimizationFlag::FastDispatch)); + + env.code_mem.emplace_back(0xd2800100); // MOV X0, 8 + env.code_mem.emplace_back(0xd61f0000); // BR X0 + env.code_mem.emplace_back(0xd2800540); // MOV X0, 42 + env.code_mem.emplace_back(0x14000000); // B . + + jit.SetPC(0); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 42); + + jit.SetPC(0); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 42); + + jit.InvalidateCacheRange(8, 4); + + jit.SetPC(0); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 42); + + env.code_mem[2] = 0xd28008a0; // MOV X0, 69 + + jit.SetPC(0); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 42); + + jit.InvalidateCacheRange(8, 4); + + jit.SetPC(0); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 69); + + jit.SetPC(0); + env.ticks_left = 4; + jit.Run(); + REQUIRE(jit.GetRegister(0) == 69); +} diff --git a/externals/dynarmic/tests/A64/testenv.h b/externals/dynarmic/tests/A64/testenv.h new file mode 100644 index 0000000000..73525242c3 --- /dev/null +++ b/externals/dynarmic/tests/A64/testenv.h @@ -0,0 +1,224 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#pragma once + +#include <array> +#include <map> + +#include <mcl/assert.hpp> +#include <mcl/stdint.hpp> + +#include "dynarmic/interface/A64/a64.h" + +using Vector = Dynarmic::A64::Vector; + +class A64TestEnv : public Dynarmic::A64::UserCallbacks { +public: + u64 ticks_left = 0; + + bool code_mem_modified_by_guest = false; + u64 code_mem_start_address = 0; + std::vector<u32> code_mem; + + std::map<u64, u8> modified_memory; + std::vector<std::string> interrupts; + + bool IsInCodeMem(u64 vaddr) const { + return vaddr >= code_mem_start_address && vaddr < code_mem_start_address + code_mem.size() * 4; + } + + std::optional<std::uint32_t> MemoryReadCode(u64 vaddr) override { + if (!IsInCodeMem(vaddr)) { + return 0x14000000; // B . + } + + const size_t index = (vaddr - code_mem_start_address) / 4; + return code_mem[index]; + } + + std::uint8_t MemoryRead8(u64 vaddr) override { + if (IsInCodeMem(vaddr)) { + return reinterpret_cast<u8*>(code_mem.data())[vaddr - code_mem_start_address]; + } + if (auto iter = modified_memory.find(vaddr); iter != modified_memory.end()) { + return iter->second; + } + return static_cast<u8>(vaddr); + } + std::uint16_t MemoryRead16(u64 vaddr) override { + return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8; + } + std::uint32_t MemoryRead32(u64 vaddr) override { + return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16; + } + std::uint64_t MemoryRead64(u64 vaddr) override { + return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32; + } + Vector MemoryRead128(u64 vaddr) override { + return {MemoryRead64(vaddr), MemoryRead64(vaddr + 8)}; + } + + void MemoryWrite8(u64 vaddr, std::uint8_t value) override { + if (IsInCodeMem(vaddr)) { + code_mem_modified_by_guest = true; + } + modified_memory[vaddr] = value; + } + void MemoryWrite16(u64 vaddr, std::uint16_t value) override { + MemoryWrite8(vaddr, static_cast<u8>(value)); + MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8)); + } + void MemoryWrite32(u64 vaddr, std::uint32_t value) override { + MemoryWrite16(vaddr, static_cast<u16>(value)); + MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16)); + } + void MemoryWrite64(u64 vaddr, std::uint64_t value) override { + MemoryWrite32(vaddr, static_cast<u32>(value)); + MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32)); + } + void MemoryWrite128(u64 vaddr, Vector value) override { + MemoryWrite64(vaddr, value[0]); + MemoryWrite64(vaddr + 8, value[1]); + } + + bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override { + MemoryWrite8(vaddr, value); + return true; + } + bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override { + MemoryWrite16(vaddr, value); + return true; + } + bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override { + MemoryWrite32(vaddr, value); + return true; + } + bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override { + MemoryWrite64(vaddr, value); + return true; + } + bool MemoryWriteExclusive128(u64 vaddr, Vector value, [[maybe_unused]] Vector expected) override { + MemoryWrite128(vaddr, value); + return true; + } + + void InterpreterFallback(u64 pc, size_t num_instructions) override { ASSERT_MSG(false, "InterpreterFallback({:016x}, {})", pc, num_instructions); } + + void CallSVC(std::uint32_t swi) override { ASSERT_MSG(false, "CallSVC({})", swi); } + + void ExceptionRaised(u64 pc, Dynarmic::A64::Exception /*exception*/) override { ASSERT_MSG(false, "ExceptionRaised({:016x})", pc); } + + void AddTicks(std::uint64_t ticks) override { + if (ticks > ticks_left) { + ticks_left = 0; + return; + } + ticks_left -= ticks; + } + std::uint64_t GetTicksRemaining() override { + return ticks_left; + } + std::uint64_t GetCNTPCT() override { + return 0x10000000000 - ticks_left; + } +}; + +class A64FastmemTestEnv final : public Dynarmic::A64::UserCallbacks { +public: + u64 ticks_left = 0; + char* backing_memory = nullptr; + + explicit A64FastmemTestEnv(char* addr) + : backing_memory(addr) {} + + template<typename T> + T read(u64 vaddr) { + T value; + memcpy(&value, backing_memory + vaddr, sizeof(T)); + return value; + } + template<typename T> + void write(u64 vaddr, const T& value) { + memcpy(backing_memory + vaddr, &value, sizeof(T)); + } + + std::optional<std::uint32_t> MemoryReadCode(u64 vaddr) override { + return read<std::uint32_t>(vaddr); + } + + std::uint8_t MemoryRead8(u64 vaddr) override { + return read<std::uint8_t>(vaddr); + } + std::uint16_t MemoryRead16(u64 vaddr) override { + return read<std::uint16_t>(vaddr); + } + std::uint32_t MemoryRead32(u64 vaddr) override { + return read<std::uint32_t>(vaddr); + } + std::uint64_t MemoryRead64(u64 vaddr) override { + return read<std::uint64_t>(vaddr); + } + Vector MemoryRead128(u64 vaddr) override { + return read<Vector>(vaddr); + } + + void MemoryWrite8(u64 vaddr, std::uint8_t value) override { + write(vaddr, value); + } + void MemoryWrite16(u64 vaddr, std::uint16_t value) override { + write(vaddr, value); + } + void MemoryWrite32(u64 vaddr, std::uint32_t value) override { + write(vaddr, value); + } + void MemoryWrite64(u64 vaddr, std::uint64_t value) override { + write(vaddr, value); + } + void MemoryWrite128(u64 vaddr, Vector value) override { + write(vaddr, value); + } + + bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override { + MemoryWrite8(vaddr, value); + return true; + } + bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override { + MemoryWrite16(vaddr, value); + return true; + } + bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override { + MemoryWrite32(vaddr, value); + return true; + } + bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override { + MemoryWrite64(vaddr, value); + return true; + } + bool MemoryWriteExclusive128(u64 vaddr, Vector value, [[maybe_unused]] Vector expected) override { + MemoryWrite128(vaddr, value); + return true; + } + + void InterpreterFallback(u64 pc, size_t num_instructions) override { ASSERT_MSG(false, "InterpreterFallback({:016x}, {})", pc, num_instructions); } + + void CallSVC(std::uint32_t swi) override { ASSERT_MSG(false, "CallSVC({})", swi); } + + void ExceptionRaised(u64 pc, Dynarmic::A64::Exception) override { ASSERT_MSG(false, "ExceptionRaised({:016x})", pc); } + + void AddTicks(std::uint64_t ticks) override { + if (ticks > ticks_left) { + ticks_left = 0; + return; + } + ticks_left -= ticks; + } + std::uint64_t GetTicksRemaining() override { + return ticks_left; + } + std::uint64_t GetCNTPCT() override { + return 0x10000000000 - ticks_left; + } +}; diff --git a/externals/dynarmic/tests/A64/verify_unicorn.cpp b/externals/dynarmic/tests/A64/verify_unicorn.cpp new file mode 100644 index 0000000000..5ffe4f15b0 --- /dev/null +++ b/externals/dynarmic/tests/A64/verify_unicorn.cpp @@ -0,0 +1,80 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <array> + +#include <catch2/catch_test_macros.hpp> + +#include "../rand_int.h" +#include "../unicorn_emu/a64_unicorn.h" +#include "./testenv.h" + +using namespace Dynarmic; + +TEST_CASE("Unicorn: Sanity test", "[a64]") { + A64TestEnv env; + + env.code_mem.emplace_back(0x8b020020); // ADD X0, X1, X2 + env.code_mem.emplace_back(0x14000000); // B . + + constexpr A64Unicorn::RegisterArray regs{ + 0, 1, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; + + A64Unicorn unicorn{env}; + + unicorn.SetRegisters(regs); + unicorn.SetPC(0); + + env.ticks_left = 2; + unicorn.Run(); + + REQUIRE(unicorn.GetRegisters()[0] == 3); + REQUIRE(unicorn.GetRegisters()[1] == 1); + REQUIRE(unicorn.GetRegisters()[2] == 2); + REQUIRE(unicorn.GetPC() == 4); +} + +TEST_CASE("Unicorn: Ensure 0xFFFF'FFFF'FFFF'FFFF is readable", "[a64]") { + A64TestEnv env; + + env.code_mem.emplace_back(0x385fed99); // LDRB W25, [X12, #0xfffffffffffffffe]! + env.code_mem.emplace_back(0x14000000); // B . + + A64Unicorn::RegisterArray regs{}; + regs[12] = 1; + + A64Unicorn unicorn{env}; + + unicorn.SetRegisters(regs); + unicorn.SetPC(0); + + env.ticks_left = 2; + unicorn.Run(); + + REQUIRE(unicorn.GetPC() == 4); +} + +TEST_CASE("Unicorn: Ensure is able to read across page boundaries", "[a64]") { + A64TestEnv env; + + env.code_mem.emplace_back(0xb85f93d9); // LDUR W25, [X30, #0xfffffffffffffff9] + env.code_mem.emplace_back(0x14000000); // B . + + A64Unicorn::RegisterArray regs{}; + regs[30] = 4; + + A64Unicorn unicorn{env}; + + unicorn.SetRegisters(regs); + unicorn.SetPC(0); + + env.ticks_left = 2; + unicorn.Run(); + + REQUIRE(unicorn.GetPC() == 4); +} diff --git a/externals/dynarmic/tests/CMakeLists.txt b/externals/dynarmic/tests/CMakeLists.txt new file mode 100644 index 0000000000..9335b972d3 --- /dev/null +++ b/externals/dynarmic/tests/CMakeLists.txt @@ -0,0 +1,128 @@ +include(TargetArchitectureSpecificSources) + +add_executable(dynarmic_tests + fp/FPToFixed.cpp + fp/FPValue.cpp + fp/mantissa_util_tests.cpp + fp/unpacked_tests.cpp + rand_int.h +) + +if ("A32" IN_LIST DYNARMIC_FRONTENDS) + target_sources(dynarmic_tests PRIVATE + A32/test_arm_disassembler.cpp + A32/test_arm_instructions.cpp + A32/test_coprocessor.cpp + A32/test_svc.cpp + A32/test_thumb_instructions.cpp + A32/testenv.h + decoder_tests.cpp + ) +endif() + +if ("A64" IN_LIST DYNARMIC_FRONTENDS) + target_link_libraries(dynarmic_tests PRIVATE merry::oaknut) + + target_sources(dynarmic_tests PRIVATE + A64/a64.cpp + A64/fibonacci.cpp + A64/fp_min_max.cpp + A64/misaligned_page_table.cpp + A64/test_invalidation.cpp + A64/testenv.h + ) +endif() + +if (DYNARMIC_TESTS_USE_UNICORN) + target_link_libraries(dynarmic_tests PRIVATE Unicorn::Unicorn) + + target_sources(dynarmic_tests PRIVATE + fuzz_util.cpp + fuzz_util.h + ) + + if ("A32" IN_LIST DYNARMIC_FRONTENDS) + target_sources(dynarmic_tests PRIVATE + A32/fuzz_arm.cpp + A32/fuzz_thumb.cpp + unicorn_emu/a32_unicorn.cpp + unicorn_emu/a32_unicorn.h + ) + endif() + + if ("A64" IN_LIST DYNARMIC_FRONTENDS) + target_sources(dynarmic_tests PRIVATE + A64/fuzz_with_unicorn.cpp + A64/verify_unicorn.cpp + unicorn_emu/a64_unicorn.cpp + unicorn_emu/a64_unicorn.h + ) + endif() +endif() + +if ("x86_64" IN_LIST ARCHITECTURE) + target_link_libraries(dynarmic_tests PRIVATE xbyak::xbyak) + + target_architecture_specific_sources(dynarmic_tests "x86_64" + x64_cpu_info.cpp + ) + + if (NOT MSVC AND NOT DYNARMIC_MULTIARCH_BUILD) + target_sources(dynarmic_tests PRIVATE + rsqrt_test.cpp + rsqrt_test_fn.s + ) + endif() +endif() + +include(CreateDirectoryGroups) + +if (("A32" IN_LIST DYNARMIC_FRONTENDS) AND ("A64" IN_LIST DYNARMIC_FRONTENDS)) + add_executable(dynarmic_print_info + print_info.cpp + ) + + create_target_directory_groups(dynarmic_print_info) + + target_link_libraries(dynarmic_print_info PRIVATE dynarmic Boost::boost fmt::fmt merry::mcl) + target_include_directories(dynarmic_print_info PRIVATE . ../src) + target_compile_options(dynarmic_print_info PRIVATE ${DYNARMIC_CXX_FLAGS}) + target_compile_definitions(dynarmic_print_info PRIVATE FMT_USE_USER_DEFINED_LITERALS=1) +endif() + +if (("A32" IN_LIST DYNARMIC_FRONTENDS) AND ("A64" IN_LIST DYNARMIC_FRONTENDS)) + add_executable(dynarmic_test_generator + fuzz_util.cpp + fuzz_util.h + test_generator.cpp + ) + + create_target_directory_groups(dynarmic_test_generator) + + target_link_libraries(dynarmic_test_generator PRIVATE dynarmic Boost::boost fmt::fmt merry::mcl) + target_include_directories(dynarmic_test_generator PRIVATE . ../src) + target_compile_options(dynarmic_test_generator PRIVATE ${DYNARMIC_CXX_FLAGS}) + target_compile_definitions(dynarmic_test_generator PRIVATE FMT_USE_USER_DEFINED_LITERALS=1) +endif() + +if (("A32" IN_LIST DYNARMIC_FRONTENDS) AND ("A64" IN_LIST DYNARMIC_FRONTENDS)) + add_executable(dynarmic_test_reader + test_reader.cpp + ) + + create_target_directory_groups(dynarmic_test_reader) + + target_link_libraries(dynarmic_test_reader PRIVATE dynarmic Boost::boost fmt::fmt merry::mcl) + target_include_directories(dynarmic_test_reader PRIVATE . ../src) + target_compile_options(dynarmic_test_reader PRIVATE ${DYNARMIC_CXX_FLAGS}) + target_compile_definitions(dynarmic_test_reader PRIVATE FMT_USE_USER_DEFINED_LITERALS=1) +endif() + +create_target_directory_groups(dynarmic_tests) + +target_link_libraries(dynarmic_tests PRIVATE dynarmic Boost::boost Catch2::Catch2WithMain fmt::fmt merry::mcl) +target_include_directories(dynarmic_tests PRIVATE . ../src) +target_compile_options(dynarmic_tests PRIVATE ${DYNARMIC_CXX_FLAGS}) +target_compile_definitions(dynarmic_tests PRIVATE FMT_USE_USER_DEFINED_LITERALS=1) + +add_test(dynarmic_tests dynarmic_tests --durations yes) diff --git a/externals/dynarmic/tests/decoder_tests.cpp b/externals/dynarmic/tests/decoder_tests.cpp new file mode 100644 index 0000000000..2028ac98cd --- /dev/null +++ b/externals/dynarmic/tests/decoder_tests.cpp @@ -0,0 +1,75 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2020 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <cstring> +#include <iomanip> +#include <iostream> + +#include <catch2/catch_test_macros.hpp> +#include <mcl/assert.hpp> + +#include "dynarmic/frontend/A32/decoder/asimd.h" +#include "dynarmic/frontend/A32/translate/impl/a32_translate_impl.h" +#include "dynarmic/interface/A32/config.h" +#include "dynarmic/ir/opcodes.h" + +using namespace Dynarmic; + +TEST_CASE("ASIMD Decoder: Ensure table order correctness", "[decode][a32][.]") { + const auto table = A32::GetASIMDDecodeTable<A32::TranslatorVisitor>(); + + const auto get_ir = [](const A32::ASIMDMatcher<A32::TranslatorVisitor>& matcher, u32 instruction) { + ASSERT(matcher.Matches(instruction)); + + const A32::LocationDescriptor location{0, {}, {}}; + IR::Block block{location}; + A32::TranslatorVisitor visitor{block, location, {}}; + matcher.call(visitor, instruction); + + return block; + }; + + const auto is_decode_error = [&get_ir](const A32::ASIMDMatcher<A32::TranslatorVisitor>& matcher, u32 instruction) { + const auto block = get_ir(matcher, instruction); + + for (const auto& ir_inst : block) { + if (ir_inst.GetOpcode() == IR::Opcode::A32ExceptionRaised) { + if (static_cast<A32::Exception>(ir_inst.GetArg(1).GetU64()) == A32::Exception::DecodeError) { + return true; + } + } + } + return false; + }; + + for (auto iter = table.cbegin(); iter != table.cend(); ++iter) { + if (std::strncmp(iter->GetName(), "UNALLOCATED", 11) == 0) { + continue; + } + + const u32 expect = iter->GetExpected(); + const u32 mask = iter->GetMask(); + u32 x = 0; + do { + const u32 instruction = expect | x; + + const bool iserr = is_decode_error(*iter, instruction); + const auto alternative = std::find_if(table.cbegin(), iter, [instruction](const auto& m) { return m.Matches(instruction); }); + const bool altiserr = is_decode_error(*alternative, instruction); + + INFO("Instruction: " << std::hex << std::setfill('0') << std::setw(8) << instruction); + INFO("Expect: " << std::hex << std::setfill('0') << std::setw(8) << expect); + INFO("Fill: " << std::hex << std::setfill('0') << std::setw(8) << x); + INFO("Name: " << iter->GetName()); + INFO("iserr: " << iserr); + INFO("alternative: " << alternative->GetName()); + INFO("altiserr: " << altiserr); + + REQUIRE(((!iserr && alternative == iter) || (iserr && alternative != iter && !altiserr))); + + x = ((x | mask) + 1) & ~mask; + } while (x != 0); + } +} diff --git a/externals/dynarmic/tests/fp/FPToFixed.cpp b/externals/dynarmic/tests/fp/FPToFixed.cpp new file mode 100644 index 0000000000..31a684a687 --- /dev/null +++ b/externals/dynarmic/tests/fp/FPToFixed.cpp @@ -0,0 +1,57 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <tuple> +#include <vector> + +#include <catch2/catch_test_macros.hpp> +#include <mcl/stdint.hpp> + +#include "../rand_int.h" +#include "dynarmic/common/fp/fpcr.h" +#include "dynarmic/common/fp/fpsr.h" +#include "dynarmic/common/fp/op.h" +#include "dynarmic/common/fp/rounding_mode.h" + +using namespace Dynarmic; +using namespace Dynarmic::FP; + +TEST_CASE("FPToFixed", "[fp]") { + const std::vector<std::tuple<u32, size_t, u64, u32>> test_cases{ + {0x447A0000, 64, 0x000003E8, 0x00}, + {0xC47A0000, 32, 0xFFFFFC18, 0x00}, + {0x4479E000, 64, 0x000003E8, 0x10}, + {0x50800000, 32, 0x7FFFFFFF, 0x01}, + {0xD0800000, 32, 0x80000000, 0x01}, + {0xCF000000, 32, 0x80000000, 0x00}, + {0x80002B94, 64, 0x00000000, 0x10}, + {0x80636D24, 64, 0x00000000, 0x10}, + }; + + const FPCR fpcr; + for (auto [input, ibits, expected_output, expected_fpsr] : test_cases) { + FPSR fpsr; + const u64 output = FPToFixed<u32>(ibits, input, 0, false, fpcr, RoundingMode::ToNearest_TieEven, fpsr); + REQUIRE(output == expected_output); + REQUIRE(fpsr.Value() == expected_fpsr); + } +} + +TEST_CASE("FPToFixed edge cases", "[fp]") { + const std::vector<std::tuple<u64, u64, bool, FP::RoundingMode>> test_cases{ + {0x41dffffffffffffe, 0x7fffffff, false, FP::RoundingMode::ToNearest_TieEven}, + {0x41dffffffffffffe, 0x7fffffff, false, FP::RoundingMode::TowardsPlusInfinity}, + {0x41dffffffffffffe, 0x7fffffff, false, FP::RoundingMode::TowardsMinusInfinity}, + {0x41dffffffffffffe, 0x7fffffff, false, FP::RoundingMode::TowardsZero}, + {0x41dffffffffffffe, 0x7fffffff, false, FP::RoundingMode::ToNearest_TieAwayFromZero}, + }; + + const FPCR fpcr; + FPSR fpsr; + for (auto [input, expected_output, unsigned_, rounding_mode] : test_cases) { + const u64 output = FPToFixed<u64>(32, input, 0, unsigned_, fpcr, rounding_mode, fpsr); + REQUIRE(output == expected_output); + } +} diff --git a/externals/dynarmic/tests/fp/FPValue.cpp b/externals/dynarmic/tests/fp/FPValue.cpp new file mode 100644 index 0000000000..b90f5f70f4 --- /dev/null +++ b/externals/dynarmic/tests/fp/FPValue.cpp @@ -0,0 +1,15 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include "dynarmic/common/fp/info.h" + +using namespace Dynarmic::FP; + +static_assert(FPValue<u32, false, 0, 1>() == 0x3f800000); +static_assert(FPValue<u32, false, -1, 3>() == 0x3fc00000); +static_assert(FPValue<u32, false, 0, 12739812>() == 0x4b4264e4); +static_assert(FPValue<u32, false, -8, 100>() == 0x3ec80000); +static_assert(FPValue<u32, true, 0, 1>() == 0xbf800000); +static_assert(FPValue<u32, false, -1, 1>() == 0x3f000000); diff --git a/externals/dynarmic/tests/fp/mantissa_util_tests.cpp b/externals/dynarmic/tests/fp/mantissa_util_tests.cpp new file mode 100644 index 0000000000..cff942c73f --- /dev/null +++ b/externals/dynarmic/tests/fp/mantissa_util_tests.cpp @@ -0,0 +1,63 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <tuple> +#include <vector> + +#include <catch2/catch_test_macros.hpp> +#include <mcl/stdint.hpp> + +#include "../rand_int.h" +#include "dynarmic/common/fp/mantissa_util.h" +#include "dynarmic/common/safe_ops.h" + +using namespace Dynarmic; +using namespace Dynarmic::FP; + +TEST_CASE("ResidualErrorOnRightShift", "[fp]") { + const std::vector<std::tuple<u32, int, ResidualError>> test_cases{ + {0x00000001, 1, ResidualError::Half}, + {0x00000002, 1, ResidualError::Zero}, + {0x00000001, 2, ResidualError::LessThanHalf}, + {0x00000002, 2, ResidualError::Half}, + {0x00000003, 2, ResidualError::GreaterThanHalf}, + {0x00000004, 2, ResidualError::Zero}, + {0x00000005, 2, ResidualError::LessThanHalf}, + {0x00000006, 2, ResidualError::Half}, + {0x00000007, 2, ResidualError::GreaterThanHalf}, + }; + + for (auto [mantissa, shift, expected_result] : test_cases) { + const ResidualError result = ResidualErrorOnRightShift(mantissa, shift); + REQUIRE(result == expected_result); + } +} + +TEST_CASE("ResidualErrorOnRightShift Randomized", "[fp]") { + for (size_t test = 0; test < 100000; test++) { + const u64 mantissa = mcl::bit::sign_extend<32, u64>(RandInt<u32>(0, 0xFFFFFFFF)); + const int shift = RandInt<int>(-60, 60); + + const ResidualError result = ResidualErrorOnRightShift(mantissa, shift); + + const u64 calculated_error = Safe::ArithmeticShiftRightDouble(mantissa, u64(0), shift); + const ResidualError expected_result = [&] { + constexpr u64 half_error = 0x8000'0000'0000'0000ull; + if (calculated_error == 0) { + return ResidualError::Zero; + } + if (calculated_error < half_error) { + return ResidualError::LessThanHalf; + } + if (calculated_error == half_error) { + return ResidualError::Half; + } + return ResidualError::GreaterThanHalf; + }(); + + INFO(std::hex << "mantissa " << mantissa << " shift " << shift << " calculated_error " << calculated_error); + REQUIRE(result == expected_result); + } +} diff --git a/externals/dynarmic/tests/fp/unpacked_tests.cpp b/externals/dynarmic/tests/fp/unpacked_tests.cpp new file mode 100644 index 0000000000..827b85ac9e --- /dev/null +++ b/externals/dynarmic/tests/fp/unpacked_tests.cpp @@ -0,0 +1,95 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <tuple> +#include <vector> + +#include <catch2/catch_test_macros.hpp> +#include <mcl/stdint.hpp> + +#include "../rand_int.h" +#include "dynarmic/common/fp/fpcr.h" +#include "dynarmic/common/fp/fpsr.h" +#include "dynarmic/common/fp/unpacked.h" + +using namespace Dynarmic; +using namespace Dynarmic::FP; + +TEST_CASE("FPUnpack Tests", "[fp]") { + const static std::vector<std::tuple<u32, std::tuple<FPType, bool, FPUnpacked>, u32>> test_cases{ + {0x00000000, {FPType::Zero, false, ToNormalized(false, 0, 0)}, 0}, + {0x7F800000, {FPType::Infinity, false, ToNormalized(false, 1000000, 1)}, 0}, + {0xFF800000, {FPType::Infinity, true, ToNormalized(true, 1000000, 1)}, 0}, + {0x7F800001, {FPType::SNaN, false, ToNormalized(false, 0, 0)}, 0}, + {0xFF800001, {FPType::SNaN, true, ToNormalized(true, 0, 0)}, 0}, + {0x7FC00001, {FPType::QNaN, false, ToNormalized(false, 0, 0)}, 0}, + {0xFFC00001, {FPType::QNaN, true, ToNormalized(true, 0, 0)}, 0}, + {0x00000001, {FPType::Nonzero, false, ToNormalized(false, -149, 1)}, 0}, // Smallest single precision denormal is 2^-149. + {0x3F7FFFFF, {FPType::Nonzero, false, ToNormalized(false, -24, 0xFFFFFF)}, 0}, // 1.0 - epsilon + }; + + const FPCR fpcr; + for (const auto& [input, expected_output, expected_fpsr] : test_cases) { + FPSR fpsr; + const auto output = FPUnpack<u32>(input, fpcr, fpsr); + + INFO("Input: " << std::hex << input); + INFO("Output Sign: " << std::get<2>(output).sign); + INFO("Output Exponent: " << std::get<2>(output).exponent); + INFO("Output Mantissa: " << std::hex << std::get<2>(output).mantissa); + INFO("Expected Sign: " << std::get<2>(expected_output).sign); + INFO("Expected Exponent: " << std::get<2>(expected_output).exponent); + INFO("Expected Mantissa: " << std::hex << std::get<2>(expected_output).mantissa); + + REQUIRE(output == expected_output); + REQUIRE(fpsr.Value() == expected_fpsr); + } +} + +TEST_CASE("FPRound Tests", "[fp]") { + const static std::vector<std::tuple<u32, std::tuple<FPType, bool, FPUnpacked>, u32>> test_cases{ + {0x7F800000, {FPType::Infinity, false, ToNormalized(false, 1000000, 1)}, 0x14}, + {0xFF800000, {FPType::Infinity, true, ToNormalized(true, 1000000, 1)}, 0x14}, + {0x00000001, {FPType::Nonzero, false, ToNormalized(false, -149, 1)}, 0}, // Smallest single precision denormal is 2^-149. + {0x3F7FFFFF, {FPType::Nonzero, false, ToNormalized(false, -24, 0xFFFFFF)}, 0}, // 1.0 - epsilon + {0x3F800000, {FPType::Nonzero, false, ToNormalized(false, -28, 0xFFFFFFF)}, 0x10}, // rounds to 1.0 + }; + + const FPCR fpcr; + for (const auto& [expected_output, input, expected_fpsr] : test_cases) { + FPSR fpsr; + const auto output = FPRound<u32>(std::get<2>(input), fpcr, fpsr); + + INFO("Expected Output: " << std::hex << expected_output); + REQUIRE(output == expected_output); + REQUIRE(fpsr.Value() == expected_fpsr); + } +} + +TEST_CASE("FPUnpack<->FPRound Round-trip Tests", "[fp]") { + const FPCR fpcr; + for (size_t count = 0; count < 100000; count++) { + FPSR fpsr; + const u32 input = RandInt(0, 1) == 0 ? RandInt<u32>(0x00000001, 0x7F800000) : RandInt<u32>(0x80000001, 0xFF800000); + const auto intermediate = std::get<2>(FPUnpack<u32>(input, fpcr, fpsr)); + const u32 output = FPRound<u32>(intermediate, fpcr, fpsr); + + INFO("Count: " << count); + INFO("Intermediate Values: " << std::hex << intermediate.sign << ';' << intermediate.exponent << ';' << intermediate.mantissa); + REQUIRE(input == output); + } +} + +TEST_CASE("FPRound (near zero, round to posinf)", "[fp]") { + const FPUnpacked input = {false, -353, 0x0a98d25ace5b2000}; + + FPSR fpsr; + FPCR fpcr; + fpcr.RMode(RoundingMode::TowardsPlusInfinity); + + const u32 output = FPRound<u32>(input, fpcr, fpsr); + + REQUIRE(output == 0x00000001); +} diff --git a/externals/dynarmic/tests/fuzz_util.cpp b/externals/dynarmic/tests/fuzz_util.cpp new file mode 100644 index 0000000000..12dc850b42 --- /dev/null +++ b/externals/dynarmic/tests/fuzz_util.cpp @@ -0,0 +1,67 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include "./fuzz_util.h" + +#include <cstring> + +#include <fmt/format.h> +#include <fmt/ostream.h> +#include <mcl/assert.hpp> + +#include "./rand_int.h" +#include "dynarmic/common/fp/fpcr.h" +#include "dynarmic/common/fp/rounding_mode.h" + +using namespace Dynarmic; + +std::ostream& operator<<(std::ostream& o, Vector vec) { + return o << fmt::format("{:016x}'{:016x}", vec[1], vec[0]); +} + +Vector RandomVector() { + return {RandInt<u64>(0, ~u64(0)), RandInt<u64>(0, ~u64(0))}; +} + +u32 RandomFpcr() { + FP::FPCR fpcr; + fpcr.AHP(RandInt(0, 1) == 0); + fpcr.DN(RandInt(0, 1) == 0); + fpcr.FZ(RandInt(0, 1) == 0); + fpcr.RMode(static_cast<FP::RoundingMode>(RandInt(0, 3))); + fpcr.FZ16(RandInt(0, 1) == 0); + return fpcr.Value(); +} + +InstructionGenerator::InstructionGenerator(const char* format) { + const size_t format_len = std::strlen(format); + ASSERT(format_len == 16 || format_len == 32); + + if (format_len == 16) { + // Begin with 16 zeros + mask |= 0xFFFF0000; + } + + for (size_t i = 0; i < format_len; i++) { + const u32 bit = 1u << (format_len - i - 1); + switch (format[i]) { + case '0': + mask |= bit; + break; + case '1': + bits |= bit; + mask |= bit; + break; + default: + // Do nothing + break; + } + } +} + +u32 InstructionGenerator::Generate() const { + const u32 random = RandInt<u32>(0, 0xFFFFFFFF); + return bits | (random & ~mask); +} diff --git a/externals/dynarmic/tests/fuzz_util.h b/externals/dynarmic/tests/fuzz_util.h new file mode 100644 index 0000000000..9530307725 --- /dev/null +++ b/externals/dynarmic/tests/fuzz_util.h @@ -0,0 +1,31 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#pragma once + +#include <array> +#include <iosfwd> + +#include <mcl/stdint.hpp> + +using Vector = std::array<u64, 2>; + +std::ostream& operator<<(std::ostream& o, Vector vec); +Vector RandomVector(); +u32 RandomFpcr(); + +struct InstructionGenerator final { +public: + explicit InstructionGenerator(const char* format); + + u32 Generate() const; + u32 Bits() const { return bits; } + u32 Mask() const { return mask; } + bool Match(u32 inst) const { return (inst & mask) == bits; } + +private: + u32 bits = 0; + u32 mask = 0; +}; diff --git a/externals/dynarmic/tests/print_info.cpp b/externals/dynarmic/tests/print_info.cpp new file mode 100644 index 0000000000..a8580b7b03 --- /dev/null +++ b/externals/dynarmic/tests/print_info.cpp @@ -0,0 +1,342 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <algorithm> +#include <cctype> +#include <cstdlib> +#include <cstring> +#include <iostream> +#include <map> +#include <optional> +#include <string> + +#include <fmt/format.h> +#include <fmt/ostream.h> +#include <mcl/bit/swap.hpp> +#include <mcl/stdint.hpp> + +#include "dynarmic/common/llvm_disassemble.h" +#include "dynarmic/frontend/A32/a32_location_descriptor.h" +#include "dynarmic/frontend/A32/decoder/arm.h" +#include "dynarmic/frontend/A32/decoder/asimd.h" +#include "dynarmic/frontend/A32/decoder/vfp.h" +#include "dynarmic/frontend/A32/translate/a32_translate.h" +#include "dynarmic/frontend/A32/translate/impl/a32_translate_impl.h" +#include "dynarmic/frontend/A64/a64_location_descriptor.h" +#include "dynarmic/frontend/A64/decoder/a64.h" +#include "dynarmic/frontend/A64/translate/a64_translate.h" +#include "dynarmic/frontend/A64/translate/impl/impl.h" +#include "dynarmic/interface/A32/a32.h" +#include "dynarmic/interface/A32/disassembler.h" +#include "dynarmic/ir/basic_block.h" +#include "dynarmic/ir/opt/passes.h" + +using namespace Dynarmic; + +const char* GetNameOfA32Instruction(u32 instruction) { + if (auto vfp_decoder = A32::DecodeVFP<A32::TranslatorVisitor>(instruction)) { + return vfp_decoder->get().GetName(); + } else if (auto asimd_decoder = A32::DecodeASIMD<A32::TranslatorVisitor>(instruction)) { + return asimd_decoder->get().GetName(); + } else if (auto decoder = A32::DecodeArm<A32::TranslatorVisitor>(instruction)) { + return decoder->get().GetName(); + } + return "<null>"; +} + +const char* GetNameOfA64Instruction(u32 instruction) { + if (auto decoder = A64::Decode<A64::TranslatorVisitor>(instruction)) { + return decoder->get().GetName(); + } + return "<null>"; +} + +void PrintA32Instruction(u32 instruction) { + fmt::print("{:08x} {}\n", instruction, Common::DisassembleAArch32(false, 0, (u8*)&instruction, sizeof(instruction))); + fmt::print("Name: {}\n", GetNameOfA32Instruction(instruction)); + + const A32::LocationDescriptor location{0, {}, {}}; + IR::Block ir_block{location}; + const bool should_continue = A32::TranslateSingleInstruction(ir_block, location, instruction); + fmt::print("should_continue: {}\n\n", should_continue); + + Optimization::NamingPass(ir_block); + + fmt::print("IR:\n"); + fmt::print("{}\n", IR::DumpBlock(ir_block)); + + Optimization::A32GetSetElimination(ir_block, {}); + Optimization::DeadCodeElimination(ir_block); + Optimization::ConstantPropagation(ir_block); + Optimization::DeadCodeElimination(ir_block); + Optimization::IdentityRemovalPass(ir_block); + + fmt::print("Optimized IR:\n"); + fmt::print("{}\n", IR::DumpBlock(ir_block)); +} + +void PrintA64Instruction(u32 instruction) { + fmt::print("{:08x} {}\n", instruction, Common::DisassembleAArch64(instruction)); + fmt::print("Name: {}\n", GetNameOfA64Instruction(instruction)); + + const A64::LocationDescriptor location{0, {}}; + IR::Block ir_block{location}; + const bool should_continue = A64::TranslateSingleInstruction(ir_block, location, instruction); + fmt::print("should_continue: {}\n\n", should_continue); + + Optimization::NamingPass(ir_block); + + fmt::print("IR:\n"); + fmt::print("{}\n", IR::DumpBlock(ir_block)); + + Optimization::A64GetSetElimination(ir_block); + Optimization::DeadCodeElimination(ir_block); + Optimization::ConstantPropagation(ir_block); + Optimization::DeadCodeElimination(ir_block); + Optimization::IdentityRemovalPass(ir_block); + + fmt::print("Optimized IR:\n"); + fmt::print("{}\n", IR::DumpBlock(ir_block)); +} + +void PrintThumbInstruction(u32 instruction) { + const size_t inst_size = (instruction >> 16) == 0 ? 2 : 4; + if (inst_size == 4) + instruction = mcl::bit::swap_halves_32(instruction); + + fmt::print("{:08x} {}\n", instruction, Common::DisassembleAArch32(true, 0, (u8*)&instruction, inst_size)); + + const A32::LocationDescriptor location{0, A32::PSR{0x1F0}, {}}; + IR::Block ir_block{location}; + const bool should_continue = A32::TranslateSingleInstruction(ir_block, location, instruction); + fmt::print("should_continue: {}\n\n", should_continue); + + Optimization::NamingPass(ir_block); + + fmt::print("IR:\n"); + fmt::print("{}\n", IR::DumpBlock(ir_block)); + + Optimization::A32GetSetElimination(ir_block, {}); + Optimization::DeadCodeElimination(ir_block); + Optimization::ConstantPropagation(ir_block); + Optimization::DeadCodeElimination(ir_block); + Optimization::IdentityRemovalPass(ir_block); + + fmt::print("Optimized IR:\n"); + fmt::print("{}\n", IR::DumpBlock(ir_block)); +} + +class ExecEnv final : public Dynarmic::A32::UserCallbacks { +public: + u64 ticks_left = 0; + std::map<u32, u8> memory; + + std::uint8_t MemoryRead8(u32 vaddr) override { + if (auto iter = memory.find(vaddr); iter != memory.end()) { + return iter->second; + } + return 0; + } + std::uint16_t MemoryRead16(u32 vaddr) override { + return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8; + } + std::uint32_t MemoryRead32(u32 vaddr) override { + return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16; + } + std::uint64_t MemoryRead64(u32 vaddr) override { + return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32; + } + + void MemoryWrite8(u32 vaddr, std::uint8_t value) override { + memory[vaddr] = value; + } + void MemoryWrite16(u32 vaddr, std::uint16_t value) override { + MemoryWrite8(vaddr, static_cast<u8>(value)); + MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8)); + } + void MemoryWrite32(u32 vaddr, std::uint32_t value) override { + MemoryWrite16(vaddr, static_cast<u16>(value)); + MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16)); + } + void MemoryWrite64(u32 vaddr, std::uint64_t value) override { + MemoryWrite32(vaddr, static_cast<u32>(value)); + MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32)); + } + + void InterpreterFallback(u32 pc, size_t num_instructions) override { + fmt::print("> InterpreterFallback({:08x}, {}) code = {:08x}\n", pc, num_instructions, *MemoryReadCode(pc)); + } + void CallSVC(std::uint32_t swi) override { + fmt::print("> CallSVC({})\n", swi); + } + void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override { + fmt::print("> ExceptionRaised({:08x}, {})", pc, static_cast<size_t>(exception)); + } + + void AddTicks(std::uint64_t ticks) override { + if (ticks > ticks_left) { + ticks_left = 0; + return; + } + ticks_left -= ticks; + } + std::uint64_t GetTicksRemaining() override { + return ticks_left; + } +}; + +void ExecuteA32Instruction(u32 instruction) { + ExecEnv env; + A32::Jit cpu{A32::UserConfig{&env}}; + env.ticks_left = 1; + + std::array<u32, 16> regs{}; + std::array<u32, 64> ext_regs{}; + u32 cpsr = 0; + u32 fpscr = 0; + + const std::map<std::string, u32*> name_map = [®s, &ext_regs, &cpsr, &fpscr] { + std::map<std::string, u32*> name_map; + for (size_t i = 0; i < regs.size(); i++) { + name_map[fmt::format("r{}", i)] = ®s[i]; + } + for (size_t i = 0; i < ext_regs.size(); i++) { + name_map[fmt::format("s{}", i)] = &ext_regs[i]; + } + name_map["sp"] = ®s[13]; + name_map["lr"] = ®s[14]; + name_map["pc"] = ®s[15]; + name_map["cpsr"] = &cpsr; + name_map["fpscr"] = &fpscr; + return name_map; + }(); + + const auto get_line = []() { + std::string line; + std::getline(std::cin, line); + std::transform(line.begin(), line.end(), line.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); }); + return line; + }; + + const auto get_value = [&get_line]() -> std::optional<u32> { + std::string line = get_line(); + if (line.length() > 2 && line[0] == '0' && line[1] == 'x') + line = line.substr(2); + if (line.length() > 8) + return std::nullopt; + + char* endptr; + const u32 value = strtol(line.c_str(), &endptr, 16); + if (line.c_str() + line.length() != endptr) + return std::nullopt; + + return value; + }; + + while (std::cin) { + fmt::print("register: "); + const std::string reg_name = get_line(); + if (const auto iter = name_map.find(reg_name); iter != name_map.end()) { + fmt::print("value: "); + if (const auto value = get_value()) { + *(iter->second) = *value; + fmt::print("> {} = 0x{:08x}\n", reg_name, *value); + } + } else if (reg_name == "mem" || reg_name == "memory") { + fmt::print("address: "); + if (const auto address = get_value()) { + fmt::print("value: "); + if (const auto value = get_value()) { + env.MemoryWrite32(*address, *value); + fmt::print("> mem[0x{:08x}] = 0x{:08x}\n", *address, *value); + } + } + } else if (reg_name == "end") { + break; + } + } + fmt::print("\n\n"); + + cpu.Regs() = regs; + cpu.ExtRegs() = ext_regs; + cpu.SetCpsr(cpsr); + cpu.SetFpscr(fpscr); + + const u32 initial_pc = regs[15]; + env.MemoryWrite32(initial_pc + 0, instruction); + env.MemoryWrite32(initial_pc + 4, 0xEAFFFFFE); // B +0 + + cpu.Run(); + + fmt::print("Registers modified:\n"); + for (size_t i = 0; i < regs.size(); ++i) { + if (regs[i] != cpu.Regs()[i]) { + fmt::print("{:3s}: {:08x}\n", static_cast<A32::Reg>(i), cpu.Regs()[i]); + } + } + for (size_t i = 0; i < ext_regs.size(); ++i) { + if (ext_regs[i] != cpu.ExtRegs()[i]) { + fmt::print("{:3s}: {:08x}\n", static_cast<A32::ExtReg>(i), cpu.Regs()[i]); + } + } + if (cpsr != cpu.Cpsr()) { + fmt::print("cpsr {:08x}\n", cpu.Cpsr()); + } + if (fpscr != cpu.Fpscr()) { + fmt::print("fpscr{:08x}\n", cpu.Fpscr()); + } + fmt::print("Modified memory:\n"); + for (auto iter = env.memory.begin(); iter != env.memory.end(); ++iter) { + fmt::print("{:08x} {:02x}\n", iter->first, iter->second); + } +} + +int main(int argc, char** argv) { + if (argc < 3 || argc > 4) { + fmt::print("usage: {} <a32/a64/thumb> <instruction_in_hex> [-exec]\n", argv[0]); + return 1; + } + + const char* const hex_instruction = [argv] { + if (strlen(argv[2]) > 2 && argv[2][0] == '0' && argv[2][1] == 'x') { + return argv[2] + 2; + } + return argv[2]; + }(); + + if (strlen(hex_instruction) > 8) { + fmt::print("hex string too long\n"); + return 1; + } + + const u32 instruction = strtol(hex_instruction, nullptr, 16); + + if (strcmp(argv[1], "a32") == 0) { + PrintA32Instruction(instruction); + } else if (strcmp(argv[1], "a64") == 0) { + PrintA64Instruction(instruction); + } else if (strcmp(argv[1], "t32") == 0 || strcmp(argv[1], "t16") == 0 || strcmp(argv[1], "thumb") == 0) { + PrintThumbInstruction(instruction); + } else { + fmt::print("Invalid mode: {}\nValid values: a32, a64, thumb\n", argv[1]); + return 1; + } + + if (argc == 4) { + if (strcmp(argv[3], "-exec") != 0) { + fmt::print("Invalid option {}\n", argv[3]); + return 1; + } + + if (strcmp(argv[1], "a32") == 0) { + ExecuteA32Instruction(instruction); + } else { + fmt::print("Executing in this mode not currently supported\n"); + return 1; + } + } + + return 0; +} diff --git a/externals/dynarmic/tests/rand_int.h b/externals/dynarmic/tests/rand_int.h new file mode 100644 index 0000000000..3997a43130 --- /dev/null +++ b/externals/dynarmic/tests/rand_int.h @@ -0,0 +1,27 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2020 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#pragma once + +#include <random> +#include <type_traits> + +namespace detail { +inline std::mt19937 g_rand_int_generator = [] { + std::random_device rd; + std::mt19937 mt{rd()}; + return mt; +}(); +} // namespace detail + +template<typename T> +T RandInt(T min, T max) { + static_assert(std::is_integral_v<T>, "T must be an integral type."); + static_assert(!std::is_same_v<T, signed char> && !std::is_same_v<T, unsigned char>, + "Using char with uniform_int_distribution is undefined behavior."); + + std::uniform_int_distribution<T> rand(min, max); + return rand(detail::g_rand_int_generator); +} diff --git a/externals/dynarmic/tests/rsqrt_test.cpp b/externals/dynarmic/tests/rsqrt_test.cpp new file mode 100644 index 0000000000..7adbe39e12 --- /dev/null +++ b/externals/dynarmic/tests/rsqrt_test.cpp @@ -0,0 +1,152 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2021 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <catch2/benchmark/catch_benchmark.hpp> +#include <catch2/catch_test_macros.hpp> +#include <fmt/printf.h> +#include <mcl/stdint.hpp> + +#include "dynarmic/common/fp/fpcr.h" +#include "dynarmic/common/fp/fpsr.h" +#include "dynarmic/common/fp/op/FPRSqrtEstimate.h" + +extern "C" u32 rsqrt_inaccurate(u32); +extern "C" u32 rsqrt_full(u32); +extern "C" u32 rsqrt_full_gpr(u32); +extern "C" u32 rsqrt_full_nb(u32); +extern "C" u32 rsqrt_full_nb2(u32); +extern "C" u32 rsqrt_full_nb_gpr(u32); +extern "C" u32 rsqrt_newton(u32); +extern "C" u32 rsqrt_hack(u32); + +using namespace Dynarmic; + +extern "C" u32 rsqrt_fallback(u32 value) { + FP::FPCR fpcr; + FP::FPSR fpsr; + return FP::FPRSqrtEstimate(value, fpcr, fpsr); +} +extern "C" u32 _rsqrt_fallback(u32 value) { + return rsqrt_fallback(value); +} + +void Test(u32 value) { + FP::FPCR fpcr; + FP::FPSR fpsr; + + const u32 expect = FP::FPRSqrtEstimate(value, fpcr, fpsr); + const u32 full = rsqrt_full(value); + const u32 full_gpr = rsqrt_full_gpr(value); + const u32 newton = rsqrt_newton(value); + const u32 hack = rsqrt_hack(value); + + if (expect != full || expect != full_gpr || expect != newton || expect != hack) { + fmt::print("{:08x} = {:08x} : {:08x} : {:08x} : {:08x} : {:08x}\n", value, expect, full, full_gpr, newton, hack); + + REQUIRE(expect == full); + REQUIRE(expect == full_gpr); + REQUIRE(expect == newton); + REQUIRE(expect == hack); + } +} + +TEST_CASE("RSqrt Tests", "[fp][.]") { + Test(0x00000000); + Test(0x80000000); + Test(0x7f8b7201); + Test(0x7f800000); + Test(0x7fc00000); + Test(0xff800000); + Test(0xffc00000); + Test(0xff800001); + + for (u64 i = 0; i < 0x1'0000'0000; i++) { + const u32 value = static_cast<u32>(i); + Test(value); + } +} + +TEST_CASE("Benchmark RSqrt", "[fp][.]") { + BENCHMARK("Inaccurate") { + u64 total = 0; + for (u64 i = 0; i < 0x1'0000'0000; i += 0x1234) { + const u32 value = static_cast<u32>(i); + total += rsqrt_inaccurate(value); + } + return total; + }; + + BENCHMARK("Full divss") { + u64 total = 0; + for (u64 i = 0; i < 0x1'0000'0000; i += 0x1234) { + const u32 value = static_cast<u32>(i); + total += rsqrt_full(value); + } + return total; + }; + + BENCHMARK("Full divss (GPR)") { + u64 total = 0; + for (u64 i = 0; i < 0x1'0000'0000; i += 0x1234) { + const u32 value = static_cast<u32>(i); + total += rsqrt_full_gpr(value); + } + return total; + }; + + BENCHMARK("Full divss (NB)") { + u64 total = 0; + for (u64 i = 0; i < 0x1'0000'0000; i += 0x1234) { + const u32 value = static_cast<u32>(i); + total += rsqrt_full_nb(value); + } + return total; + }; + + BENCHMARK("Full divss (NB2)") { + u64 total = 0; + for (u64 i = 0; i < 0x1'0000'0000; i += 0x1234) { + const u32 value = static_cast<u32>(i); + total += rsqrt_full_nb2(value); + } + return total; + }; + + BENCHMARK("Full divss (NB + GPR)") { + u64 total = 0; + for (u64 i = 0; i < 0x1'0000'0000; i += 0x1234) { + const u32 value = static_cast<u32>(i); + total += rsqrt_full_nb_gpr(value); + } + return total; + }; + + BENCHMARK("One Newton iteration") { + u64 total = 0; + for (u64 i = 0; i < 0x1'0000'0000; i += 0x1234) { + const u32 value = static_cast<u32>(i); + total += rsqrt_newton(value); + } + return total; + }; + + BENCHMARK("Ugly Hack") { + u64 total = 0; + for (u64 i = 0; i < 0x1'0000'0000; i += 0x1234) { + const u32 value = static_cast<u32>(i); + total += rsqrt_hack(value); + } + return total; + }; + + BENCHMARK("Softfloat") { + u64 total = 0; + for (u64 i = 0; i < 0x1'0000'0000; i += 0x1234) { + const u32 value = static_cast<u32>(i); + total += rsqrt_fallback(value); + } + return total; + }; +} diff --git a/externals/dynarmic/tests/rsqrt_test_fn.s b/externals/dynarmic/tests/rsqrt_test_fn.s new file mode 100644 index 0000000000..fa8dadee01 --- /dev/null +++ b/externals/dynarmic/tests/rsqrt_test_fn.s @@ -0,0 +1,303 @@ +.global _rsqrt_inaccurate +.global rsqrt_inaccurate +.global _rsqrt_full +.global rsqrt_full +.global _rsqrt_full_gpr +.global rsqrt_full_gpr +.global _rsqrt_full_nb +.global rsqrt_full_nb +.global _rsqrt_full_nb2 +.global rsqrt_full_nb2 +.global _rsqrt_full_nb_gpr +.global rsqrt_full_nb_gpr +.global _rsqrt_newton +.global rsqrt_newton +.global _rsqrt_hack +.global rsqrt_hack +.global _rsqrt_fallback + +.text +.intel_syntax noprefix + +.align 16 +min_pos_denorm: +.long 0x00800000,0,0,0 +penultimate_bit: +.long 0x00008000,0,0,0 +ultimate_bit: +.long 0x00004000,0,0,0 +top_mask: +.long 0xFFFF8000,0,0,0 +one: +.long 0x3f800000,0,0,0 +half: +.long 0x3f000000,0,0,0 +one_point_five: +.long 0x3fc00000,0,0,0 +magic1: +.long 0x60000000,0,0,0 +magic2: +.long 0x3c000000,0,0,0 +magic3: +.long 0x000047ff,0,0,0 + +_rsqrt_inaccurate: +rsqrt_inaccurate: + movd xmm0, edi + + rsqrtss xmm0, xmm0 + + movd eax, xmm0 + ret + +_rsqrt_full: +rsqrt_full: + movd xmm0, edi + + pand xmm0, [rip + top_mask] + por xmm0, [rip + penultimate_bit] + + vcmpngt_uqss xmm1, xmm0, [rip + min_pos_denorm] + ptest xmm1, xmm1 + jnz rsqrt_full_bad + + sqrtss xmm0, xmm0 + + movd xmm1, [rip + one] + divss xmm1, xmm0 + + paddd xmm1, [rip + ultimate_bit] + pand xmm1, [rip + top_mask] + + movd eax, xmm1 + ret + +_rsqrt_full_gpr: +rsqrt_full_gpr: + movd eax, xmm0 # Emulate regalloc mov + + mov eax, edi + and eax, 0xFFFF8000 + or eax, 0x00008000 + + movd xmm0, eax + vcmpngt_uqss xmm1, xmm0, [rip + min_pos_denorm] + ptest xmm1, xmm1 + jnz rsqrt_full_bad + + sqrtss xmm0, xmm0 + + movd xmm1, [rip + one] + divss xmm1, xmm0 + movd eax, xmm1 + + add eax, 0x00004000 + and eax, 0xffff8000 + + movd xmm0, eax # Emulate regalloc mov + ret + +_rsqrt_full_nb2: +rsqrt_full_nb2: + movd xmm0, edi + + pand xmm0, [rip + top_mask] + por xmm0, [rip + penultimate_bit] + + ucomiss xmm0, [rip + min_pos_denorm] + jna rsqrt_full_bad_new1 + + sqrtss xmm0, xmm0 + + movd xmm1, [rip + one] + divss xmm1, xmm0 + + paddd xmm1, [rip + ultimate_bit] + pand xmm1, [rip + top_mask] + + movd eax, xmm1 + ret + +_rsqrt_full_nb: +rsqrt_full_nb: + movd xmm0, edi + + pand xmm0, [rip + top_mask] + por xmm0, [rip + penultimate_bit] + + vcmpngt_uqss xmm1, xmm0, [rip + min_pos_denorm] + ptest xmm1, xmm1 + jnz rsqrt_full_bad_new1 + + sqrtss xmm0, xmm0 + + movd xmm1, [rip + one] + divss xmm1, xmm0 + + paddd xmm1, [rip + ultimate_bit] + pand xmm1, [rip + top_mask] + + movd eax, xmm1 + ret + +rsqrt_full_bad_new1: + cmp edi, 0x00800000 + jb rsqrt_full_bad_new_fallback1 + + movd xmm0, edi + rsqrtss xmm1, xmm0 + + ucomiss xmm1, xmm1 + jp rsqrt_full_bad_new1_nan + + movd eax, xmm1 + ret + +rsqrt_full_bad_new_fallback1: + call _rsqrt_fallback + ret + +rsqrt_full_bad_new1_nan: + ucomiss xmm0, xmm0 + jp rsqrt_full_bad_new1_nan_ret + + mov eax, 0x7FC00000 + ret + +rsqrt_full_bad_new1_nan_ret: + ret + +_rsqrt_full_nb_gpr: +rsqrt_full_nb_gpr: + movd eax, xmm0 # Emulate regalloc mov + + mov eax, edi + and eax, 0xFFFF8000 + or eax, 0x00008000 + + movd xmm0, eax + vcmpngt_uqss xmm1, xmm0, [rip + min_pos_denorm] + ptest xmm1, xmm1 + jnz rsqrt_full_bad_new2 + + sqrtss xmm0, xmm0 + + movd xmm1, [rip + one] + divss xmm1, xmm0 + movd eax, xmm1 + + add eax, 0x00004000 + and eax, 0xffff8000 + + movd xmm0, eax # Emulate regalloc mov + ret + +rsqrt_full_bad_new2: + cmp edi, 0x00800000 + jb rsqrt_full_bad_new_fallback2 + + movd xmm0, edi + rsqrtss xmm1, xmm0 + + test edi, edi + js rsqrt_full_bad_new2_nan + + movd eax, xmm1 + ret + +rsqrt_full_bad_new_fallback2: + call _rsqrt_fallback + ret + +rsqrt_full_bad_new2_nan: + mov eax, 0x7FC00000 + ret + +rsqrt_full_bad: + xorps xmm1, xmm1 + movd xmm0, edi + ucomiss xmm0, xmm1 + jp rsqrt_full_nan + je rsqrt_full_zero + jc rsqrt_full_neg + + cmp edi, 0x7F800000 + je rsqrt_full_inf + + # TODO: Full Denormal Implementation + call _rsqrt_fallback + ret + +rsqrt_full_neg: + mov eax, 0x7FC00000 + ret + +rsqrt_full_inf: + xor eax, eax + ret + +rsqrt_full_nan: + mov eax, edi + or eax, 0x00400000 + ret + +rsqrt_full_zero: + mov eax, edi + or eax, 0x7F800000 + ret + +_rsqrt_newton: +rsqrt_newton: + movd xmm0, edi + + pand xmm0, [rip + top_mask] + por xmm0, [rip + penultimate_bit] + + vcmpngt_uqss xmm1, xmm0, [rip + min_pos_denorm] + ptest xmm1, xmm1 + jnz rsqrt_full_bad + + rsqrtps xmm1, xmm0 + mulss xmm0, [rip + half] + vmulss xmm2, xmm1, xmm1 + mulss xmm2, xmm0 + movaps xmm0, [rip + one_point_five] + subss xmm0, xmm2 + mulss xmm0, xmm1 + + paddd xmm0, [rip + ultimate_bit] + pand xmm0, [rip + top_mask] + + movd eax, xmm0 + ret + +_rsqrt_hack: +rsqrt_hack: + movd xmm9, edi + + vpand xmm0, xmm9, [rip + top_mask] + por xmm0, [rip + penultimate_bit] + + # detect NaNs, negatives, zeros, denormals and infinities + vcmpngt_uqss xmm1, xmm0, [rip + min_pos_denorm] + ptest xmm1, xmm1 + jnz rsqrt_full_bad + + # calculate x64 estimate + rsqrtps xmm0, xmm0 + + # calculate correction factor + vpslld xmm1, xmm9, 8 + vpsrad xmm2, xmm1, 31 + paddd xmm1, [rip + magic1] + pcmpgtd xmm1, [rip + magic2] + pxor xmm1, xmm2 + movaps xmm2, [rip + magic3] + psubd xmm2, xmm1 + + # correct x64 estimate + paddd xmm0, xmm2 + pand xmm0, [rip + top_mask] + + movd eax, xmm0 + ret diff --git a/externals/dynarmic/tests/test_generator.cpp b/externals/dynarmic/tests/test_generator.cpp new file mode 100644 index 0000000000..cfdd8ea436 --- /dev/null +++ b/externals/dynarmic/tests/test_generator.cpp @@ -0,0 +1,700 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2022 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <algorithm> +#include <array> +#include <cstdio> +#include <cstdlib> +#include <functional> +#include <limits> +#include <optional> +#include <tuple> +#include <vector> + +#include <mcl/bit/swap.hpp> +#include <mcl/macro/architecture.hpp> +#include <mcl/stdint.hpp> + +#include "./A32/testenv.h" +#include "./A64/testenv.h" +#include "./fuzz_util.h" +#include "./rand_int.h" +#include "dynarmic/common/fp/fpcr.h" +#include "dynarmic/common/fp/fpsr.h" +#include "dynarmic/frontend/A32/ITState.h" +#include "dynarmic/frontend/A32/a32_location_descriptor.h" +#include "dynarmic/frontend/A32/a32_types.h" +#include "dynarmic/frontend/A32/translate/a32_translate.h" +#include "dynarmic/frontend/A64/a64_location_descriptor.h" +#include "dynarmic/frontend/A64/a64_types.h" +#include "dynarmic/frontend/A64/translate/a64_translate.h" +#include "dynarmic/interface/A32/a32.h" +#include "dynarmic/interface/A64/a64.h" +#include "dynarmic/ir/basic_block.h" +#include "dynarmic/ir/location_descriptor.h" +#include "dynarmic/ir/opcodes.h" + +// Must be declared last for all necessary operator<< to be declared prior to this. +#include <fmt/format.h> +#include <fmt/ostream.h> + +constexpr bool mask_fpsr_cum_bits = true; + +namespace { +using namespace Dynarmic; + +bool ShouldTestInst(IR::Block& block) { + if (auto terminal = block.GetTerminal(); boost::get<IR::Term::Interpret>(&terminal)) { + return false; + } + + for (const auto& ir_inst : block) { + switch (ir_inst.GetOpcode()) { + // A32 + case IR::Opcode::A32GetFpscr: + case IR::Opcode::A32ExceptionRaised: + case IR::Opcode::A32CallSupervisor: + case IR::Opcode::A32CoprocInternalOperation: + case IR::Opcode::A32CoprocSendOneWord: + case IR::Opcode::A32CoprocSendTwoWords: + case IR::Opcode::A32CoprocGetOneWord: + case IR::Opcode::A32CoprocGetTwoWords: + case IR::Opcode::A32CoprocLoadWords: + case IR::Opcode::A32CoprocStoreWords: + // A64 + case IR::Opcode::A64ExceptionRaised: + case IR::Opcode::A64CallSupervisor: + case IR::Opcode::A64DataCacheOperationRaised: + case IR::Opcode::A64GetCNTPCT: + // Unimplemented + case IR::Opcode::SignedSaturatedAdd8: + case IR::Opcode::SignedSaturatedAdd16: + case IR::Opcode::SignedSaturatedAdd32: + case IR::Opcode::SignedSaturatedAdd64: + case IR::Opcode::SignedSaturatedDoublingMultiplyReturnHigh16: + case IR::Opcode::SignedSaturatedDoublingMultiplyReturnHigh32: + case IR::Opcode::SignedSaturatedSub8: + case IR::Opcode::SignedSaturatedSub16: + case IR::Opcode::SignedSaturatedSub32: + case IR::Opcode::SignedSaturatedSub64: + case IR::Opcode::UnsignedSaturatedAdd8: + case IR::Opcode::UnsignedSaturatedAdd16: + case IR::Opcode::UnsignedSaturatedAdd32: + case IR::Opcode::UnsignedSaturatedAdd64: + case IR::Opcode::UnsignedSaturatedSub8: + case IR::Opcode::UnsignedSaturatedSub16: + case IR::Opcode::UnsignedSaturatedSub32: + case IR::Opcode::UnsignedSaturatedSub64: + case IR::Opcode::VectorMaxS64: + case IR::Opcode::VectorMaxU64: + case IR::Opcode::VectorMinS64: + case IR::Opcode::VectorMinU64: + case IR::Opcode::VectorMultiply64: + case IR::Opcode::SM4AccessSubstitutionBox: + // Half-prec conversions + case IR::Opcode::FPHalfToFixedS16: + case IR::Opcode::FPHalfToFixedS32: + case IR::Opcode::FPHalfToFixedS64: + case IR::Opcode::FPHalfToFixedU16: + case IR::Opcode::FPHalfToFixedU32: + case IR::Opcode::FPHalfToFixedU64: + // Half-precision + case IR::Opcode::FPAbs16: + case IR::Opcode::FPMulAdd16: + case IR::Opcode::FPMulSub16: + case IR::Opcode::FPNeg16: + case IR::Opcode::FPRecipEstimate16: + case IR::Opcode::FPRecipExponent16: + case IR::Opcode::FPRecipStepFused16: + case IR::Opcode::FPRoundInt16: + case IR::Opcode::FPRSqrtEstimate16: + case IR::Opcode::FPRSqrtStepFused16: + case IR::Opcode::FPVectorAbs16: + case IR::Opcode::FPVectorEqual16: + case IR::Opcode::FPVectorMulAdd16: + case IR::Opcode::FPVectorNeg16: + case IR::Opcode::FPVectorRecipEstimate16: + case IR::Opcode::FPVectorRecipStepFused16: + case IR::Opcode::FPVectorRoundInt16: + case IR::Opcode::FPVectorRSqrtEstimate16: + case IR::Opcode::FPVectorRSqrtStepFused16: + case IR::Opcode::FPVectorToSignedFixed16: + case IR::Opcode::FPVectorToUnsignedFixed16: + case IR::Opcode::FPVectorFromHalf32: + case IR::Opcode::FPVectorToHalf32: + return false; + default: + continue; + } + } + + return true; +} + +bool ShouldTestA32Inst(u32 instruction, u32 pc, bool is_thumb, bool is_last_inst, A32::ITState it_state = {}) { + const A32::LocationDescriptor location = A32::LocationDescriptor{pc, {}, {}}.SetTFlag(is_thumb).SetIT(it_state); + IR::Block block{location}; + const bool should_continue = A32::TranslateSingleInstruction(block, location, instruction); + + if (!should_continue && !is_last_inst) { + return false; + } + + return ShouldTestInst(block); +} + +bool ShouldTestA64Inst(u32 instruction, u64 pc, bool is_last_inst) { + const A64::LocationDescriptor location = A64::LocationDescriptor{pc, {}}; + IR::Block block{location}; + const bool should_continue = A64::TranslateSingleInstruction(block, location, instruction); + + if (!should_continue && !is_last_inst) { + return false; + } + + return ShouldTestInst(block); +} + +u32 GenRandomArmInst(u32 pc, bool is_last_inst) { + static const struct InstructionGeneratorInfo { + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + } instructions = [] { + const std::vector<std::tuple<std::string, const char*>> list{ +#define INST(fn, name, bitstring) {#fn, bitstring}, +#include "dynarmic/frontend/A32/decoder/arm.inc" +#include "dynarmic/frontend/A32/decoder/asimd.inc" +#include "dynarmic/frontend/A32/decoder/vfp.inc" +#undef INST + }; + + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + + // List of instructions not to test + static constexpr std::array do_not_test{ + // Translating load/stores + "arm_LDRBT", "arm_LDRBT", "arm_LDRHT", "arm_LDRHT", "arm_LDRSBT", "arm_LDRSBT", "arm_LDRSHT", "arm_LDRSHT", "arm_LDRT", "arm_LDRT", + "arm_STRBT", "arm_STRBT", "arm_STRHT", "arm_STRHT", "arm_STRT", "arm_STRT", + // Exclusive load/stores + "arm_LDREXB", "arm_LDREXD", "arm_LDREXH", "arm_LDREX", "arm_LDAEXB", "arm_LDAEXD", "arm_LDAEXH", "arm_LDAEX", + "arm_STREXB", "arm_STREXD", "arm_STREXH", "arm_STREX", "arm_STLEXB", "arm_STLEXD", "arm_STLEXH", "arm_STLEX", + "arm_SWP", "arm_SWPB", + // Elevated load/store multiple instructions. + "arm_LDM_eret", "arm_LDM_usr", + "arm_STM_usr", + // Coprocessor + "arm_CDP", "arm_LDC", "arm_MCR", "arm_MCRR", "arm_MRC", "arm_MRRC", "arm_STC", + // System + "arm_CPS", "arm_RFE", "arm_SRS", + // Undefined + "arm_UDF", + // FPSCR is inaccurate + "vfp_VMRS", + // Incorrect Unicorn implementations + "asimd_VRECPS", // Unicorn does not fuse the multiply and subtraction, resulting in being off by 1ULP. + "asimd_VRSQRTS", // Unicorn does not fuse the multiply and subtraction, resulting in being off by 1ULP. + "vfp_VCVT_from_fixed", // Unicorn does not do round-to-nearest-even for this instruction correctly. + }; + + for (const auto& [fn, bitstring] : list) { + if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + invalid.emplace_back(InstructionGenerator{bitstring}); + continue; + } + generators.emplace_back(InstructionGenerator{bitstring}); + } + return InstructionGeneratorInfo{generators, invalid}; + }(); + + while (true) { + const size_t index = RandInt<size_t>(0, instructions.generators.size() - 1); + const u32 inst = instructions.generators[index].Generate(); + + if ((instructions.generators[index].Mask() & 0xF0000000) == 0 && (inst & 0xF0000000) == 0xF0000000) { + continue; + } + + if (ShouldTestA32Inst(inst, pc, false, is_last_inst)) { + return inst; + } + } +} + +std::vector<u16> GenRandomThumbInst(u32 pc, bool is_last_inst, A32::ITState it_state = {}) { + static const struct InstructionGeneratorInfo { + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + } instructions = [] { + const std::vector<std::tuple<std::string, const char*>> list{ +#define INST(fn, name, bitstring) {#fn, bitstring}, +#include "dynarmic/frontend/A32/decoder/thumb16.inc" +#include "dynarmic/frontend/A32/decoder/thumb32.inc" +#undef INST + }; + + const std::vector<std::tuple<std::string, const char*>> vfp_list{ +#define INST(fn, name, bitstring) {#fn, bitstring}, +#include "dynarmic/frontend/A32/decoder/vfp.inc" +#undef INST + }; + + const std::vector<std::tuple<std::string, const char*>> asimd_list{ +#define INST(fn, name, bitstring) {#fn, bitstring}, +#include "dynarmic/frontend/A32/decoder/asimd.inc" +#undef INST + }; + + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + + // List of instructions not to test + static constexpr std::array do_not_test{ + "thumb16_BKPT", + "thumb16_IT", + + // Exclusive load/stores + "thumb32_LDREX", + "thumb32_LDREXB", + "thumb32_LDREXD", + "thumb32_LDREXH", + "thumb32_STREX", + "thumb32_STREXB", + "thumb32_STREXD", + "thumb32_STREXH", + + // Coprocessor + "thumb32_CDP", + "thumb32_LDC", + "thumb32_MCR", + "thumb32_MCRR", + "thumb32_MRC", + "thumb32_MRRC", + "thumb32_STC", + }; + + for (const auto& [fn, bitstring] : list) { + if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + invalid.emplace_back(InstructionGenerator{bitstring}); + continue; + } + generators.emplace_back(InstructionGenerator{bitstring}); + } + for (const auto& [fn, bs] : vfp_list) { + std::string bitstring = bs; + if (bitstring.substr(0, 4) == "cccc" || bitstring.substr(0, 4) == "----") { + bitstring.replace(0, 4, "1110"); + } + if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + invalid.emplace_back(InstructionGenerator{bitstring.c_str()}); + continue; + } + generators.emplace_back(InstructionGenerator{bitstring.c_str()}); + } + for (const auto& [fn, bs] : asimd_list) { + std::string bitstring = bs; + if (bitstring.substr(0, 7) == "1111001") { + const char U = bitstring[7]; + bitstring.replace(0, 8, "111-1111"); + bitstring[3] = U; + } else if (bitstring.substr(0, 8) == "11110100") { + bitstring.replace(0, 8, "11111001"); + } else { + ASSERT_FALSE("Unhandled ASIMD instruction: {} {}", fn, bs); + } + if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + invalid.emplace_back(InstructionGenerator{bitstring.c_str()}); + continue; + } + generators.emplace_back(InstructionGenerator{bitstring.c_str()}); + } + return InstructionGeneratorInfo{generators, invalid}; + }(); + + while (true) { + const size_t index = RandInt<size_t>(0, instructions.generators.size() - 1); + const u32 inst = instructions.generators[index].Generate(); + const bool is_four_bytes = (inst >> 16) != 0; + + if (ShouldTestA32Inst(is_four_bytes ? mcl::bit::swap_halves_32(inst) : inst, pc, true, is_last_inst, it_state)) { + if (is_four_bytes) + return {static_cast<u16>(inst >> 16), static_cast<u16>(inst)}; + return {static_cast<u16>(inst)}; + } + } +} + +u32 GenRandomA64Inst(u64 pc, bool is_last_inst) { + static const struct InstructionGeneratorInfo { + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + } instructions = [] { + const std::vector<std::tuple<std::string, const char*>> list{ +#define INST(fn, name, bitstring) {#fn, bitstring}, +#include "dynarmic/frontend/A64/decoder/a64.inc" +#undef INST + }; + + std::vector<InstructionGenerator> generators; + std::vector<InstructionGenerator> invalid; + + // List of instructions not to test + const std::vector<std::string> do_not_test{ + // Dynarmic and QEMU currently differ on how the exclusive monitor's address range works. + "STXR", + "STLXR", + "STXP", + "STLXP", + "LDXR", + "LDAXR", + "LDXP", + "LDAXP", + // Behaviour differs from QEMU + "MSR_reg", + "MSR_imm", + "MRS", + }; + + for (const auto& [fn, bitstring] : list) { + if (fn == "UnallocatedEncoding") { + continue; + } + if (std::find(do_not_test.begin(), do_not_test.end(), fn) != do_not_test.end()) { + invalid.emplace_back(InstructionGenerator{bitstring}); + continue; + } + generators.emplace_back(InstructionGenerator{bitstring}); + } + return InstructionGeneratorInfo{generators, invalid}; + }(); + + while (true) { + const size_t index = RandInt<size_t>(0, instructions.generators.size() - 1); + const u32 inst = instructions.generators[index].Generate(); + + if (std::any_of(instructions.invalid.begin(), instructions.invalid.end(), [inst](const auto& invalid) { return invalid.Match(inst); })) { + continue; + } + if (ShouldTestA64Inst(inst, pc, is_last_inst)) { + return inst; + } + } +} + +template<typename TestEnv> +Dynarmic::A32::UserConfig GetA32UserConfig(TestEnv& testenv, bool noopt) { + Dynarmic::A32::UserConfig user_config; + user_config.optimizations &= ~OptimizationFlag::FastDispatch; + user_config.callbacks = &testenv; + if (noopt) { + user_config.optimizations = no_optimizations; + } + return user_config; +} + +template<size_t num_jit_reruns = 1, typename TestEnv> +void RunTestInstance(Dynarmic::A32::Jit& jit, + TestEnv& jit_env, + const std::array<u32, 16>& regs, + const std::array<u32, 64>& vecs, + const std::vector<typename TestEnv::InstructionType>& instructions, + const u32 cpsr, + const u32 fpscr, + const size_t ticks_left) { + const u32 initial_pc = regs[15]; + const u32 num_words = initial_pc / sizeof(typename TestEnv::InstructionType); + const u32 code_mem_size = num_words + static_cast<u32>(instructions.size()); + + fmt::print("instructions:"); + for (auto instruction : instructions) { + if constexpr (sizeof(decltype(instruction)) == 2) { + fmt::print(" {:04x}", instruction); + } else { + fmt::print(" {:08x}", instruction); + } + } + fmt::print("\n"); + + fmt::print("initial_regs:"); + for (u32 i : regs) { + fmt::print(" {:08x}", i); + } + fmt::print("\n"); + fmt::print("initial_vecs:"); + for (u32 i : vecs) { + fmt::print(" {:08x}", i); + } + fmt::print("\n"); + fmt::print("initial_cpsr: {:08x}\n", cpsr); + fmt::print("initial_fpcr: {:08x}\n", fpscr); + + jit.ClearCache(); + + for (size_t jit_rerun_count = 0; jit_rerun_count < num_jit_reruns; ++jit_rerun_count) { + jit_env.code_mem.resize(code_mem_size); + std::fill(jit_env.code_mem.begin(), jit_env.code_mem.end(), TestEnv::infinite_loop); + + std::copy(instructions.begin(), instructions.end(), jit_env.code_mem.begin() + num_words); + jit_env.PadCodeMem(); + jit_env.modified_memory.clear(); + jit_env.interrupts.clear(); + + jit.Regs() = regs; + jit.ExtRegs() = vecs; + jit.SetFpscr(fpscr); + jit.SetCpsr(cpsr); + + jit_env.ticks_left = ticks_left; + jit.Run(); + } + + fmt::print("final_regs:"); + for (u32 i : jit.Regs()) { + fmt::print(" {:08x}", i); + } + fmt::print("\n"); + fmt::print("final_vecs:"); + for (u32 i : jit.ExtRegs()) { + fmt::print(" {:08x}", i); + } + fmt::print("\n"); + fmt::print("final_cpsr: {:08x}\n", jit.Cpsr()); + fmt::print("final_fpsr: {:08x}\n", mask_fpsr_cum_bits ? jit.Fpscr() & 0xffffff00 : jit.Fpscr()); + + fmt::print("mod_mem: "); + for (auto [addr, value] : jit_env.modified_memory) { + fmt::print("{:08x}:{:02x} ", addr, value); + } + fmt::print("\n"); + + fmt::print("interrupts:\n"); + for (const auto& i : jit_env.interrupts) { + std::puts(i.c_str()); + } + + fmt::print("===\n"); +} + +Dynarmic::A64::UserConfig GetA64UserConfig(A64TestEnv& jit_env, bool noopt) { + Dynarmic::A64::UserConfig jit_user_config{&jit_env}; + jit_user_config.optimizations &= ~OptimizationFlag::FastDispatch; + // The below corresponds to the settings for qemu's aarch64_max_initfn + jit_user_config.dczid_el0 = 7; + jit_user_config.ctr_el0 = 0x80038003; + if (noopt) { + jit_user_config.optimizations = no_optimizations; + } + return jit_user_config; +} + +template<size_t num_jit_reruns = 2> +void RunTestInstance(Dynarmic::A64::Jit& jit, + A64TestEnv& jit_env, + const std::array<u64, 31>& regs, + const std::array<std::array<u64, 2>, 32>& vecs, + const std::vector<u32>& instructions, + const u32 pstate, + const u32 fpcr, + const u64 initial_sp, + const u64 start_address, + const size_t ticks_left) { + jit.ClearCache(); + + for (size_t jit_rerun_count = 0; jit_rerun_count < num_jit_reruns; ++jit_rerun_count) { + jit_env.code_mem = instructions; + jit_env.code_mem.emplace_back(0x14000000); // B . + jit_env.code_mem_start_address = start_address; + jit_env.modified_memory.clear(); + jit_env.interrupts.clear(); + + jit.SetRegisters(regs); + jit.SetVectors(vecs); + jit.SetPC(start_address); + jit.SetSP(initial_sp); + jit.SetFpcr(fpcr); + jit.SetFpsr(0); + jit.SetPstate(pstate); + jit.ClearCache(); + + jit_env.ticks_left = ticks_left; + jit.Run(); + } + + fmt::print("instructions:"); + for (u32 instruction : instructions) { + fmt::print(" {:08x}", instruction); + } + fmt::print("\n"); + + fmt::print("initial_regs:"); + for (u64 i : regs) { + fmt::print(" {:016x}", i); + } + fmt::print("\n"); + fmt::print("initial_vecs:"); + for (auto i : vecs) { + fmt::print(" {:016x}:{:016x}", i[0], i[1]); + } + fmt::print("\n"); + fmt::print("initial_sp: {:016x}\n", initial_sp); + fmt::print("initial_pstate: {:08x}\n", pstate); + fmt::print("initial_fpcr: {:08x}\n", fpcr); + + fmt::print("final_regs:"); + for (u64 i : jit.GetRegisters()) { + fmt::print(" {:016x}", i); + } + fmt::print("\n"); + fmt::print("final_vecs:"); + for (auto i : jit.GetVectors()) { + fmt::print(" {:016x}:{:016x}", i[0], i[1]); + } + fmt::print("\n"); + fmt::print("final_sp: {:016x}\n", jit.GetSP()); + fmt::print("final_pc: {:016x}\n", jit.GetPC()); + fmt::print("final_pstate: {:08x}\n", jit.GetPstate()); + fmt::print("final_fpcr: {:08x}\n", jit.GetFpcr()); + fmt::print("final_qc : {}\n", FP::FPSR{jit.GetFpsr()}.QC()); + + fmt::print("mod_mem:"); + for (auto [addr, value] : jit_env.modified_memory) { + fmt::print(" {:08x}:{:02x}", addr, value); + } + fmt::print("\n"); + + fmt::print("interrupts:\n"); + for (const auto& i : jit_env.interrupts) { + std::puts(i.c_str()); + } + + fmt::print("===\n"); +} + +} // Anonymous namespace + +void TestThumb(size_t num_instructions, size_t num_iterations, bool noopt) { + ThumbTestEnv jit_env{}; + Dynarmic::A32::Jit jit{GetA32UserConfig(jit_env, noopt)}; + + std::array<u32, 16> regs; + std::array<u32, 64> ext_reg; + std::vector<u16> instructions; + + for (size_t iteration = 0; iteration < num_iterations; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + std::generate(ext_reg.begin(), ext_reg.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + + const u32 start_address = 100; + const u32 cpsr = (RandInt<u32>(0, 0xF) << 28) | 0x1F0; + const u32 fpcr = RandomFpcr(); + + instructions.clear(); + for (size_t i = 0; i < num_instructions; ++i) { + const auto inst = GenRandomThumbInst(static_cast<u32>(start_address + 2 * instructions.size()), i == num_instructions - 1); + instructions.insert(instructions.end(), inst.begin(), inst.end()); + } + + regs[15] = start_address; + RunTestInstance(jit, jit_env, regs, ext_reg, instructions, cpsr, fpcr, num_instructions); + } +} + +void TestArm(size_t num_instructions, size_t num_iterations, bool noopt) { + ArmTestEnv jit_env{}; + Dynarmic::A32::Jit jit{GetA32UserConfig(jit_env, noopt)}; + + std::array<u32, 16> regs; + std::array<u32, 64> ext_reg; + std::vector<u32> instructions; + + for (size_t iteration = 0; iteration < num_iterations; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + std::generate(ext_reg.begin(), ext_reg.end(), [] { return RandInt<u32>(0, ~u32(0)); }); + + const u32 start_address = 100; + const u32 cpsr = (RandInt<u32>(0, 0xF) << 28); + const u32 fpcr = RandomFpcr(); + + instructions.clear(); + for (size_t i = 0; i < num_instructions; ++i) { + instructions.emplace_back(GenRandomArmInst(static_cast<u32>(start_address + 4 * instructions.size()), i == num_instructions - 1)); + } + + regs[15] = start_address; + RunTestInstance(jit, jit_env, regs, ext_reg, instructions, cpsr, fpcr, num_instructions); + } +} + +void TestA64(size_t num_instructions, size_t num_iterations, bool noopt) { + A64TestEnv jit_env{}; + Dynarmic::A64::Jit jit{GetA64UserConfig(jit_env, noopt)}; + + std::array<u64, 31> regs; + std::array<std::array<u64, 2>, 32> vecs; + std::vector<u32> instructions; + + for (size_t iteration = 0; iteration < num_iterations; ++iteration) { + std::generate(regs.begin(), regs.end(), [] { return RandInt<u64>(0, ~u64(0)); }); + std::generate(vecs.begin(), vecs.end(), RandomVector); + + const u32 start_address = 100; + const u32 pstate = (RandInt<u32>(0, 0xF) << 28); + const u32 fpcr = RandomFpcr(); + const u64 initial_sp = RandInt<u64>(0x30'0000'0000, 0x40'0000'0000) * 4; + + instructions.clear(); + for (size_t i = 0; i < num_instructions; ++i) { + instructions.emplace_back(GenRandomA64Inst(static_cast<u32>(start_address + 4 * instructions.size()), i == num_instructions - 1)); + } + + RunTestInstance(jit, jit_env, regs, vecs, instructions, pstate, fpcr, initial_sp, start_address, num_instructions); + } +} + +static std::optional<size_t> str2sz(char const* s) { + char* end = nullptr; + errno = 0; + + const long l = std::strtol(s, &end, 10); + if (errno == ERANGE || l < 0) { + return std::nullopt; + } + if (*s == '\0' || *end != '\0') { + return std::nullopt; + } + return static_cast<size_t>(l); +} + +int main(int argc, char* argv[]) { + if (argc < 5 || argc > 6) { + fmt::print("Usage: {} <thumb|arm|a64> <seed> <instruction_count> <iteration_count> [noopt]\n", argv[0]); + return 1; + } + + const auto seed = str2sz(argv[2]); + const auto instruction_count = str2sz(argv[3]); + const auto iterator_count = str2sz(argv[4]); + const bool noopt = argc == 6 && (strcmp(argv[5], "noopt") == 0); + + if (!seed || !instruction_count || !iterator_count) { + fmt::print("invalid numeric arguments\n"); + return 1; + } + + detail::g_rand_int_generator.seed(static_cast<std::mt19937::result_type>(*seed)); + + if (strcmp(argv[1], "thumb") == 0) { + TestThumb(*instruction_count, *iterator_count, noopt); + } else if (strcmp(argv[1], "arm") == 0) { + TestArm(*instruction_count, *iterator_count, noopt); + } else if (strcmp(argv[1], "a64") == 0) { + TestA64(*instruction_count, *iterator_count, noopt); + } else { + fmt::print("unrecognized instruction class\n"); + return 1; + } + + return 0; +} diff --git a/externals/dynarmic/tests/test_reader.cpp b/externals/dynarmic/tests/test_reader.cpp new file mode 100644 index 0000000000..44d6e966ea --- /dev/null +++ b/externals/dynarmic/tests/test_reader.cpp @@ -0,0 +1,427 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2023 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <array> +#include <iostream> +#include <string> +#include <string_view> +#include <vector> + +#include <fmt/format.h> +#include <mcl/stdint.hpp> + +#include "./A32/testenv.h" +#include "./A64/testenv.h" +#include "dynarmic/common/fp/fpsr.h" +#include "dynarmic/interface/A32/a32.h" +#include "dynarmic/interface/A64/a64.h" + +const bool mask_fpsr_cum_bits = true; + +using namespace Dynarmic; + +void SkipWhitespace(std::string_view& sv) { + auto nextpos{sv.find_first_not_of(' ')}; + if (nextpos != std::string::npos) { + sv.remove_prefix(nextpos); + } +} + +void SkipHeader(std::string_view& sv) { + sv.remove_prefix(sv.find_first_of(':') + 1); + SkipWhitespace(sv); +} + +std::string_view NextToken(std::string_view& sv) { + auto nextpos{sv.find_first_of(' ')}; + auto tok{sv.substr(0, nextpos)}; + sv.remove_prefix(nextpos == std::string::npos ? sv.size() : nextpos); + SkipWhitespace(sv); + return tok; +} + +u64 ParseHex(std::string_view hex) { + u64 result = 0; + while (!hex.empty()) { + result <<= 4; + if (hex.front() >= '0' && hex.front() <= '9') { + result += hex.front() - '0'; + } else if (hex.front() >= 'a' && hex.front() <= 'f') { + result += hex.front() - 'a' + 0xA; + } else if (hex.front() >= 'A' && hex.front() <= 'F') { + result += hex.front() - 'A' + 0xA; + } else if (hex.front() == ':') { + return result; + } else { + fmt::print("Character {} is not a valid hex character\n", hex.front()); + } + hex.remove_prefix(1); + } + return result; +} + +template<typename TestEnv> +Dynarmic::A32::UserConfig GetA32UserConfig(TestEnv& testenv, bool noopt) { + Dynarmic::A32::UserConfig user_config; + user_config.optimizations &= ~OptimizationFlag::FastDispatch; + user_config.callbacks = &testenv; + user_config.very_verbose_debugging_output = true; + if (noopt) { + user_config.optimizations = no_optimizations; + } + return user_config; +} + +template<size_t num_jit_reruns = 1, typename TestEnv> +void RunTestInstance(Dynarmic::A32::Jit& jit, + TestEnv& jit_env, + const std::array<u32, 16>& regs, + const std::array<u32, 64>& vecs, + const std::vector<typename TestEnv::InstructionType>& instructions, + const u32 cpsr, + const u32 fpscr, + const size_t ticks_left) { + const u32 initial_pc = regs[15]; + const u32 num_words = initial_pc / sizeof(typename TestEnv::InstructionType); + const u32 code_mem_size = num_words + static_cast<u32>(instructions.size()); + + jit.ClearCache(); + + for (size_t jit_rerun_count = 0; jit_rerun_count < num_jit_reruns; ++jit_rerun_count) { + jit_env.code_mem.resize(code_mem_size); + std::fill(jit_env.code_mem.begin(), jit_env.code_mem.end(), TestEnv::infinite_loop); + + std::copy(instructions.begin(), instructions.end(), jit_env.code_mem.begin() + num_words); + jit_env.PadCodeMem(); + jit_env.modified_memory.clear(); + jit_env.interrupts.clear(); + + jit.Regs() = regs; + jit.ExtRegs() = vecs; + jit.SetFpscr(fpscr); + jit.SetCpsr(cpsr); + + jit_env.ticks_left = ticks_left; + jit.Run(); + } + + fmt::print("instructions:"); + for (auto instruction : instructions) { + if constexpr (sizeof(decltype(instruction)) == 2) { + fmt::print(" {:04x}", instruction); + } else { + fmt::print(" {:08x}", instruction); + } + } + fmt::print("\n"); + + fmt::print("initial_regs:"); + for (u32 i : regs) { + fmt::print(" {:08x}", i); + } + fmt::print("\n"); + fmt::print("initial_vecs:"); + for (u32 i : vecs) { + fmt::print(" {:08x}", i); + } + fmt::print("\n"); + fmt::print("initial_cpsr: {:08x}\n", cpsr); + fmt::print("initial_fpcr: {:08x}\n", fpscr); + + fmt::print("final_regs:"); + for (u32 i : jit.Regs()) { + fmt::print(" {:08x}", i); + } + fmt::print("\n"); + fmt::print("final_vecs:"); + for (u32 i : jit.ExtRegs()) { + fmt::print(" {:08x}", i); + } + fmt::print("\n"); + fmt::print("final_cpsr: {:08x}\n", jit.Cpsr()); + fmt::print("final_fpsr: {:08x}\n", mask_fpsr_cum_bits ? jit.Fpscr() & 0xffffff00 : jit.Fpscr()); + + fmt::print("mod_mem: "); + for (auto [addr, value] : jit_env.modified_memory) { + fmt::print("{:08x}:{:02x} ", addr, value); + } + fmt::print("\n"); + + fmt::print("interrupts:\n"); + for (const auto& i : jit_env.interrupts) { + std::puts(i.c_str()); + } + + fmt::print("===\n"); +} + +A64::UserConfig GetA64UserConfig(A64TestEnv& jit_env, bool noopt) { + A64::UserConfig jit_user_config{&jit_env}; + jit_user_config.optimizations &= ~OptimizationFlag::FastDispatch; + // The below corresponds to the settings for qemu's aarch64_max_initfn + jit_user_config.dczid_el0 = 7; + jit_user_config.ctr_el0 = 0x80038003; + jit_user_config.very_verbose_debugging_output = true; + if (noopt) { + jit_user_config.optimizations = no_optimizations; + } + return jit_user_config; +} + +template<size_t num_jit_reruns = 1> +void RunTestInstance(A64::Jit& jit, + A64TestEnv& jit_env, + const std::array<u64, 31>& regs, + const std::array<std::array<u64, 2>, 32>& vecs, + const std::vector<u32>& instructions, + const u32 pstate, + const u32 fpcr, + const u64 initial_sp, + const u64 start_address, + const size_t ticks_left) { + jit.ClearCache(); + + for (size_t jit_rerun_count = 0; jit_rerun_count < num_jit_reruns; ++jit_rerun_count) { + jit_env.code_mem = instructions; + jit_env.code_mem.emplace_back(0x14000000); // B . + jit_env.code_mem_start_address = start_address; + jit_env.modified_memory.clear(); + jit_env.interrupts.clear(); + + jit.SetRegisters(regs); + jit.SetVectors(vecs); + jit.SetPC(start_address); + jit.SetSP(initial_sp); + jit.SetFpcr(fpcr); + jit.SetFpsr(0); + jit.SetPstate(pstate); + jit.ClearCache(); + + jit_env.ticks_left = ticks_left; + jit.Run(); + } + + fmt::print("instructions:"); + for (u32 instruction : instructions) { + fmt::print(" {:08x}", instruction); + } + fmt::print("\n"); + + fmt::print("initial_regs:"); + for (u64 i : regs) { + fmt::print(" {:016x}", i); + } + fmt::print("\n"); + fmt::print("initial_vecs:"); + for (auto i : vecs) { + fmt::print(" {:016x}:{:016x}", i[0], i[1]); + } + fmt::print("\n"); + fmt::print("initial_sp: {:016x}\n", initial_sp); + fmt::print("initial_pstate: {:08x}\n", pstate); + fmt::print("initial_fpcr: {:08x}\n", fpcr); + + fmt::print("final_regs:"); + for (u64 i : jit.GetRegisters()) { + fmt::print(" {:016x}", i); + } + fmt::print("\n"); + fmt::print("final_vecs:"); + for (auto i : jit.GetVectors()) { + fmt::print(" {:016x}:{:016x}", i[0], i[1]); + } + fmt::print("\n"); + fmt::print("final_sp: {:016x}\n", jit.GetSP()); + fmt::print("final_pc: {:016x}\n", jit.GetPC()); + fmt::print("final_pstate: {:08x}\n", jit.GetPstate()); + fmt::print("final_fpcr: {:08x}\n", jit.GetFpcr()); + fmt::print("final_qc : {}\n", FP::FPSR{jit.GetFpsr()}.QC()); + + fmt::print("mod_mem:"); + for (auto [addr, value] : jit_env.modified_memory) { + fmt::print(" {:08x}:{:02x}", addr, value); + } + fmt::print("\n"); + + fmt::print("interrupts:\n"); + for (const auto& i : jit_env.interrupts) { + std::puts(i.c_str()); + } + + fmt::print("===\n"); +} + +void RunThumb(bool noopt) { + std::array<u32, 16> initial_regs{}; + std::array<u32, 64> initial_vecs{}; + std::vector<u16> instructions{}; + u32 initial_cpsr = 0; + u32 initial_fpcr = 0; + + std::string line; + while (std::getline(std::cin, line)) { + std::string_view sv{line}; + + if (sv.starts_with("instructions:")) { + SkipHeader(sv); + while (!sv.empty()) { + instructions.emplace_back((u16)ParseHex(NextToken(sv))); + } + } else if (sv.starts_with("initial_regs:")) { + SkipHeader(sv); + for (size_t i = 0; i < initial_regs.size(); ++i) { + initial_regs[i] = (u32)ParseHex(NextToken(sv)); + } + } else if (sv.starts_with("initial_vecs:")) { + SkipHeader(sv); + for (size_t i = 0; i < initial_vecs.size(); ++i) { + initial_vecs[i] = (u32)ParseHex(NextToken(sv)); + } + } else if (sv.starts_with("initial_cpsr:")) { + SkipHeader(sv); + initial_cpsr = (u32)ParseHex(NextToken(sv)); + } else if (sv.starts_with("initial_fpcr:")) { + SkipHeader(sv); + initial_fpcr = (u32)ParseHex(NextToken(sv)); + } + } + + ThumbTestEnv jit_env{}; + A32::Jit jit{GetA32UserConfig(jit_env, noopt)}; + RunTestInstance(jit, + jit_env, + initial_regs, + initial_vecs, + instructions, + initial_cpsr, + initial_fpcr, + instructions.size()); +} + +void RunArm(bool noopt) { + std::array<u32, 16> initial_regs{}; + std::array<u32, 64> initial_vecs{}; + std::vector<u32> instructions{}; + u32 initial_cpsr = 0; + u32 initial_fpcr = 0; + + std::string line; + while (std::getline(std::cin, line)) { + std::string_view sv{line}; + + if (sv.starts_with("instructions:")) { + SkipHeader(sv); + while (!sv.empty()) { + instructions.emplace_back((u32)ParseHex(NextToken(sv))); + } + } else if (sv.starts_with("initial_regs:")) { + SkipHeader(sv); + for (size_t i = 0; i < initial_regs.size(); ++i) { + initial_regs[i] = (u32)ParseHex(NextToken(sv)); + } + } else if (sv.starts_with("initial_vecs:")) { + SkipHeader(sv); + for (size_t i = 0; i < initial_vecs.size(); ++i) { + initial_vecs[i] = (u32)ParseHex(NextToken(sv)); + } + } else if (sv.starts_with("initial_cpsr:")) { + SkipHeader(sv); + initial_cpsr = (u32)ParseHex(NextToken(sv)); + } else if (sv.starts_with("initial_fpcr:")) { + SkipHeader(sv); + initial_fpcr = (u32)ParseHex(NextToken(sv)); + } + } + + ArmTestEnv jit_env{}; + A32::Jit jit{GetA32UserConfig(jit_env, noopt)}; + RunTestInstance(jit, + jit_env, + initial_regs, + initial_vecs, + instructions, + initial_cpsr, + initial_fpcr, + instructions.size()); +} + +void RunA64(bool noopt) { + std::array<u64, 31> initial_regs{}; + std::array<std::array<u64, 2>, 32> initial_vecs{}; + std::vector<u32> instructions{}; + u32 initial_pstate = 0; + u32 initial_fpcr = 0; + u64 initial_sp = 0; + u64 start_address = 100; + + std::string line; + while (std::getline(std::cin, line)) { + std::string_view sv{line}; + + if (sv.starts_with("instructions:")) { + SkipHeader(sv); + while (!sv.empty()) { + instructions.emplace_back((u32)ParseHex(NextToken(sv))); + } + } else if (sv.starts_with("initial_regs:")) { + SkipHeader(sv); + for (size_t i = 0; i < initial_regs.size(); ++i) { + initial_regs[i] = ParseHex(NextToken(sv)); + } + } else if (sv.starts_with("initial_vecs:")) { + SkipHeader(sv); + for (size_t i = 0; i < initial_vecs.size(); ++i) { + auto tok{NextToken(sv)}; + initial_vecs[i][0] = ParseHex(tok); + tok.remove_prefix(tok.find_first_of(':') + 1); + initial_vecs[i][1] = ParseHex(tok); + } + } else if (sv.starts_with("initial_sp:")) { + SkipHeader(sv); + initial_sp = ParseHex(NextToken(sv)); + } else if (sv.starts_with("initial_pstate:")) { + SkipHeader(sv); + initial_pstate = (u32)ParseHex(NextToken(sv)); + } else if (sv.starts_with("initial_fpcr:")) { + SkipHeader(sv); + initial_fpcr = (u32)ParseHex(NextToken(sv)); + } + } + + A64TestEnv jit_env{}; + A64::Jit jit{GetA64UserConfig(jit_env, noopt)}; + RunTestInstance(jit, + jit_env, + initial_regs, + initial_vecs, + instructions, + initial_pstate, + initial_fpcr, + initial_sp, + start_address, + instructions.size()); +} + +int main(int argc, char** argv) { + if (argc < 2 || argc > 3) { + fmt::print("Usage: {} <thumb|arm|a64> [noopt]\n", argv[0]); + return 1; + } + + const bool noopt = argc == 3 && (strcmp(argv[2], "noopt") == 0); + + if (strcmp(argv[1], "thumb") == 0) { + RunThumb(noopt); + } else if (strcmp(argv[1], "arm") == 0) { + RunArm(noopt); + } else if (strcmp(argv[1], "a64") == 0) { + RunA64(noopt); + } else { + fmt::print("unrecognized instruction class\n"); + return 1; + } + + return 0; +} diff --git a/externals/dynarmic/tests/unicorn_emu/a32_unicorn.cpp b/externals/dynarmic/tests/unicorn_emu/a32_unicorn.cpp new file mode 100644 index 0000000000..db704c97df --- /dev/null +++ b/externals/dynarmic/tests/unicorn_emu/a32_unicorn.cpp @@ -0,0 +1,351 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include "./a32_unicorn.h" + +#include <type_traits> + +#include <mcl/assert.hpp> +#include <mcl/bit/bit_field.hpp> + +#include "../A32/testenv.h" + +#define CHECKED(expr) \ + do { \ + if (auto cerr_ = (expr)) { \ + ASSERT_MSG(false, "Call " #expr " failed with error: {} ({})\n", static_cast<size_t>(cerr_), \ + uc_strerror(cerr_)); \ + } \ + } while (0) + +constexpr u32 BEGIN_ADDRESS = 0; +constexpr u32 END_ADDRESS = ~u32(0); + +template<class TestEnvironment> +A32Unicorn<TestEnvironment>::A32Unicorn(TestEnvironment& testenv) + : testenv{testenv} { + constexpr uc_mode open_mode = std::is_same_v<TestEnvironment, ArmTestEnv> ? UC_MODE_ARM : UC_MODE_THUMB; + + CHECKED(uc_open(UC_ARCH_ARM, open_mode, &uc)); + CHECKED(uc_hook_add(uc, &intr_hook, UC_HOOK_INTR, (void*)InterruptHook, this, BEGIN_ADDRESS, END_ADDRESS)); + CHECKED(uc_hook_add(uc, &mem_invalid_hook, UC_HOOK_MEM_INVALID, (void*)UnmappedMemoryHook, this, BEGIN_ADDRESS, END_ADDRESS)); + CHECKED(uc_hook_add(uc, &mem_write_prot_hook, UC_HOOK_MEM_WRITE, (void*)MemoryWriteHook, this, BEGIN_ADDRESS, END_ADDRESS)); +} + +template<class TestEnvironment> +A32Unicorn<TestEnvironment>::~A32Unicorn() { + ClearPageCache(); + CHECKED(uc_hook_del(uc, intr_hook)); + CHECKED(uc_hook_del(uc, mem_invalid_hook)); + CHECKED(uc_close(uc)); +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::Run() { + // Thumb execution mode requires the LSB to be set to 1. + constexpr u64 pc_mask = std::is_same_v<TestEnvironment, ArmTestEnv> ? 0 : 1; + while (testenv.ticks_left > 0) { + const u32 pc = GetPC() | pc_mask; + if (!testenv.IsInCodeMem(pc)) { + return; + } + if (auto cerr_ = uc_emu_start(uc, pc, END_ADDRESS, 0, 1)) { + fmt::print("uc_emu_start failed @ {:08x} (code = {:08x}) with error {} ({})", pc, *testenv.MemoryReadCode(pc), static_cast<size_t>(cerr_), uc_strerror(cerr_)); + throw "A32Unicorn::Run() failure"; + } + testenv.ticks_left--; + if (!testenv.interrupts.empty() || testenv.code_mem_modified_by_guest) { + return; + } + } + + const bool T = mcl::bit::get_bit<5>(GetCpsr()); + const u32 new_pc = GetPC() | (T ? 1 : 0); + SetPC(new_pc); +} + +template<class TestEnvironment> +u32 A32Unicorn<TestEnvironment>::GetPC() const { + u32 pc; + CHECKED(uc_reg_read(uc, UC_ARM_REG_PC, &pc)); + return pc; +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::SetPC(u32 value) { + CHECKED(uc_reg_write(uc, UC_ARM_REG_PC, &value)); +} + +template<class TestEnvironment> +u32 A32Unicorn<TestEnvironment>::GetSP() const { + u32 sp; + CHECKED(uc_reg_read(uc, UC_ARM_REG_SP, &sp)); + return sp; +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::SetSP(u32 value) { + CHECKED(uc_reg_write(uc, UC_ARM_REG_SP, &value)); +} + +constexpr std::array<int, Unicorn::A32::num_gprs> gpr_ids{ + UC_ARM_REG_R0, + UC_ARM_REG_R1, + UC_ARM_REG_R2, + UC_ARM_REG_R3, + UC_ARM_REG_R4, + UC_ARM_REG_R5, + UC_ARM_REG_R6, + UC_ARM_REG_R7, + UC_ARM_REG_R8, + UC_ARM_REG_R9, + UC_ARM_REG_R10, + UC_ARM_REG_R11, + UC_ARM_REG_R12, + UC_ARM_REG_R13, + UC_ARM_REG_R14, + UC_ARM_REG_R15, +}; + +template<class TestEnvironment> +Unicorn::A32::RegisterArray A32Unicorn<TestEnvironment>::GetRegisters() const { + Unicorn::A32::RegisterArray regs{}; + Unicorn::A32::RegisterPtrArray ptrs; + for (size_t i = 0; i < ptrs.size(); ++i) { + ptrs[i] = ®s[i]; + } + + CHECKED(uc_reg_read_batch(uc, const_cast<int*>(gpr_ids.data()), + reinterpret_cast<void**>(ptrs.data()), static_cast<int>(Unicorn::A32::num_gprs))); + return regs; +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::SetRegisters(const RegisterArray& value) { + Unicorn::A32::RegisterConstPtrArray ptrs; + for (size_t i = 0; i < ptrs.size(); ++i) { + ptrs[i] = &value[i]; + } + + CHECKED(uc_reg_write_batch(uc, const_cast<int*>(gpr_ids.data()), + reinterpret_cast<void**>(const_cast<u32**>(ptrs.data())), static_cast<int>(ptrs.size()))); +} + +using DoubleExtRegPtrArray = std::array<Unicorn::A32::ExtRegArray::pointer, Unicorn::A32::num_ext_regs / 2>; +using DoubleExtRegConstPtrArray = std::array<Unicorn::A32::ExtRegArray::const_pointer, Unicorn::A32::num_ext_regs / 2>; + +constexpr std::array<int, Unicorn::A32::num_ext_regs / 2> double_ext_reg_ids{ + UC_ARM_REG_D0, + UC_ARM_REG_D1, + UC_ARM_REG_D2, + UC_ARM_REG_D3, + UC_ARM_REG_D4, + UC_ARM_REG_D5, + UC_ARM_REG_D6, + UC_ARM_REG_D7, + UC_ARM_REG_D8, + UC_ARM_REG_D9, + UC_ARM_REG_D10, + UC_ARM_REG_D11, + UC_ARM_REG_D12, + UC_ARM_REG_D13, + UC_ARM_REG_D14, + UC_ARM_REG_D15, + UC_ARM_REG_D16, + UC_ARM_REG_D17, + UC_ARM_REG_D18, + UC_ARM_REG_D19, + UC_ARM_REG_D20, + UC_ARM_REG_D21, + UC_ARM_REG_D22, + UC_ARM_REG_D23, + UC_ARM_REG_D24, + UC_ARM_REG_D25, + UC_ARM_REG_D26, + UC_ARM_REG_D27, + UC_ARM_REG_D28, + UC_ARM_REG_D29, + UC_ARM_REG_D30, + UC_ARM_REG_D31, +}; + +template<class TestEnvironment> +Unicorn::A32::ExtRegArray A32Unicorn<TestEnvironment>::GetExtRegs() const { + Unicorn::A32::ExtRegArray ext_regs{}; + DoubleExtRegPtrArray ptrs; + for (size_t i = 0; i < ptrs.size(); ++i) + ptrs[i] = &ext_regs[i * 2]; + + CHECKED(uc_reg_read_batch(uc, const_cast<int*>(double_ext_reg_ids.data()), + reinterpret_cast<void**>(ptrs.data()), static_cast<int>(ptrs.size()))); + + return ext_regs; +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::SetExtRegs(const ExtRegArray& value) { + DoubleExtRegConstPtrArray ptrs; + for (size_t i = 0; i < ptrs.size(); ++i) { + ptrs[i] = &value[i * 2]; + } + + CHECKED(uc_reg_write_batch(uc, const_cast<int*>(double_ext_reg_ids.data()), + reinterpret_cast<void* const*>(const_cast<u32**>(ptrs.data())), static_cast<int>(ptrs.size()))); +} + +template<class TestEnvironment> +u32 A32Unicorn<TestEnvironment>::GetFpscr() const { + u32 fpsr; + CHECKED(uc_reg_read(uc, UC_ARM_REG_FPSCR, &fpsr)); + return fpsr; +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::SetFpscr(u32 value) { + CHECKED(uc_reg_write(uc, UC_ARM_REG_FPSCR, &value)); +} + +template<class TestEnvironment> +u32 A32Unicorn<TestEnvironment>::GetFpexc() const { + u32 value = 0; + CHECKED(uc_reg_read(uc, UC_ARM_REG_FPEXC, &value)); + return value; +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::SetFpexc(u32 value) { + CHECKED(uc_reg_write(uc, UC_ARM_REG_FPEXC, &value)); +} + +template<class TestEnvironment> +u32 A32Unicorn<TestEnvironment>::GetCpsr() const { + u32 pstate; + CHECKED(uc_reg_read(uc, UC_ARM_REG_CPSR, &pstate)); + return pstate; +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::SetCpsr(u32 value) { + CHECKED(uc_reg_write(uc, UC_ARM_REG_CPSR, &value)); +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::EnableFloatingPointAccess() { + const u32 new_fpexc = GetFpexc() | (1U << 30); + SetFpexc(new_fpexc); +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::ClearPageCache() { + for (const auto& page : pages) { + CHECKED(uc_mem_unmap(uc, page->address, 4096)); + } + pages.clear(); +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::DumpMemoryInformation() { + uc_mem_region* regions; + u32 count; + CHECKED(uc_mem_regions(uc, ®ions, &count)); + + for (u32 i = 0; i < count; ++i) { + printf("region: start 0x%08x end 0x%08x perms 0x%08x\n", static_cast<u32>(regions[i].begin), static_cast<u32>(regions[i].end), regions[i].perms); + } + + CHECKED(uc_free(regions)); +} + +template<class TestEnvironment> +void A32Unicorn<TestEnvironment>::InterruptHook(uc_engine* /*uc*/, u32 int_number, void* user_data) { + auto* this_ = static_cast<A32Unicorn*>(user_data); + + u32 esr = 0; + // CHECKED(uc_reg_read(uc, UC_ARM_REG_ESR, &esr)); + + auto ec = esr >> 26; + auto iss = esr & 0xFFFFFF; + + switch (ec) { + case 0x15: // SVC + this_->testenv.CallSVC(iss); + break; + default: + this_->testenv.interrupts.emplace_back(fmt::format("Unhandled interrupt: int_number: {:#x}, esr: {:#x} (ec: {:#x}, iss: {:#x})", int_number, esr, ec, iss)); + break; + } +} + +template<class TestEnvironment> +bool A32Unicorn<TestEnvironment>::UnmappedMemoryHook(uc_engine* uc, uc_mem_type /*type*/, u32 start_address, int size, u64 /*value*/, void* user_data) { + auto* this_ = static_cast<A32Unicorn*>(user_data); + + const auto generate_page = [&](u32 base_address) { + // printf("generate_page(%x)\n", base_address); + + const u32 permissions = [&]() -> u32 { + if (base_address < this_->testenv.code_mem.size() * sizeof(typename TestEnvironment::InstructionType)) { + return UC_PROT_READ | UC_PROT_EXEC; + } + return UC_PROT_READ; + }(); + + auto page = std::make_unique<Page>(); + page->address = base_address; + for (size_t i = 0; i < page->data.size(); ++i) + page->data[i] = this_->testenv.MemoryRead8(static_cast<u32>(base_address + i)); + + uc_err err = uc_mem_map_ptr(uc, base_address, page->data.size(), permissions, page->data.data()); + if (err == UC_ERR_MAP) + return; // page already exists + CHECKED(err); + + this_->pages.emplace_back(std::move(page)); + }; + + const auto is_in_range = [](u32 addr, u32 start, u32 end) { + if (start <= end) + return addr >= start && addr <= end; // fffff[tttttt]fffff + return addr >= start || addr <= end; // ttttt]ffffff[ttttt + }; + + const u32 start_address_page = start_address & ~u32(0xFFF); + const u32 end_address = start_address + size - 1; + + u32 current_address = start_address_page; + do { + generate_page(current_address); + current_address += 0x1000; + } while (is_in_range(current_address, start_address_page, end_address) && current_address != start_address_page); + + return true; +} + +template<class TestEnvironment> +bool A32Unicorn<TestEnvironment>::MemoryWriteHook(uc_engine* /*uc*/, uc_mem_type /*type*/, u32 start_address, int size, u64 value, void* user_data) { + auto* this_ = static_cast<A32Unicorn*>(user_data); + + switch (size) { + case 1: + this_->testenv.MemoryWrite8(start_address, static_cast<u8>(value)); + break; + case 2: + this_->testenv.MemoryWrite16(start_address, static_cast<u16>(value)); + break; + case 4: + this_->testenv.MemoryWrite32(start_address, static_cast<u32>(value)); + break; + case 8: + this_->testenv.MemoryWrite64(start_address, value); + break; + default: + UNREACHABLE(); + } + + return true; +} + +template class A32Unicorn<ArmTestEnv>; +template class A32Unicorn<ThumbTestEnv>; diff --git a/externals/dynarmic/tests/unicorn_emu/a32_unicorn.h b/externals/dynarmic/tests/unicorn_emu/a32_unicorn.h new file mode 100644 index 0000000000..d4fe3c41a4 --- /dev/null +++ b/externals/dynarmic/tests/unicorn_emu/a32_unicorn.h @@ -0,0 +1,88 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#pragma once + +#include <array> +#include <vector> + +#ifdef _MSC_VER +# pragma warning(push, 0) +# include <unicorn/unicorn.h> +# pragma warning(pop) +#else +# include <unicorn/unicorn.h> +#endif + +#include <mcl/stdint.hpp> + +#include "../A32/testenv.h" + +namespace Unicorn::A32 { +static constexpr size_t num_gprs = 16; +static constexpr size_t num_ext_regs = 64; + +using ExtRegArray = std::array<u32, num_ext_regs>; +using RegisterArray = std::array<u32, num_gprs>; +using RegisterPtrArray = std::array<RegisterArray::pointer, num_gprs>; +using RegisterConstPtrArray = std::array<RegisterArray::const_pointer, num_gprs>; +} // namespace Unicorn::A32 + +template<class TestEnvironment> +class A32Unicorn final { +public: + using ExtRegArray = Unicorn::A32::ExtRegArray; + using RegisterArray = Unicorn::A32::RegisterArray; + + explicit A32Unicorn(TestEnvironment& testenv); + ~A32Unicorn(); + + void Run(); + + u32 GetSP() const; + void SetSP(u32 value); + + u32 GetPC() const; + void SetPC(u32 value); + + RegisterArray GetRegisters() const; + void SetRegisters(const RegisterArray& value); + + ExtRegArray GetExtRegs() const; + void SetExtRegs(const ExtRegArray& value); + + u32 GetFpscr() const; + void SetFpscr(u32 value); + + u32 GetFpexc() const; + void SetFpexc(u32 value); + + u32 GetCpsr() const; + void SetCpsr(u32 value); + + void EnableFloatingPointAccess(); + + void ClearPageCache(); + + void DumpMemoryInformation(); + +private: + static void InterruptHook(uc_engine* uc, u32 interrupt, void* user_data); + static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u32 addr, int size, u64 value, void* user_data); + static bool MemoryWriteHook(uc_engine* uc, uc_mem_type type, u32 addr, int size, u64 value, void* user_data); + + struct Page { + u32 address; + std::array<u8, 4096> data; + }; + + TestEnvironment& testenv; + uc_engine* uc{}; + uc_hook intr_hook{}; + uc_hook mem_invalid_hook{}; + uc_hook mem_write_prot_hook{}; + + std::vector<std::unique_ptr<Page>> pages; +}; diff --git a/externals/dynarmic/tests/unicorn_emu/a64_unicorn.cpp b/externals/dynarmic/tests/unicorn_emu/a64_unicorn.cpp new file mode 100644 index 0000000000..3c202c7c8e --- /dev/null +++ b/externals/dynarmic/tests/unicorn_emu/a64_unicorn.cpp @@ -0,0 +1,252 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include "./a64_unicorn.h" + +#include <mcl/assert.hpp> + +#define CHECKED(expr) \ + do { \ + if (auto cerr_ = (expr)) { \ + ASSERT_MSG(false, "Call " #expr " failed with error: {} ({})\n", static_cast<size_t>(cerr_), \ + uc_strerror(cerr_)); \ + } \ + } while (0) + +constexpr u64 BEGIN_ADDRESS = 0; +constexpr u64 END_ADDRESS = ~u64(0); + +A64Unicorn::A64Unicorn(A64TestEnv& testenv) + : testenv(testenv) { + CHECKED(uc_open(UC_ARCH_ARM64, UC_MODE_ARM, &uc)); + u64 fpv = 3 << 20; + CHECKED(uc_reg_write(uc, UC_ARM64_REG_CPACR_EL1, &fpv)); + CHECKED(uc_hook_add(uc, &intr_hook, UC_HOOK_INTR, (void*)InterruptHook, this, BEGIN_ADDRESS, END_ADDRESS)); + CHECKED(uc_hook_add(uc, &mem_invalid_hook, UC_HOOK_MEM_INVALID, (void*)UnmappedMemoryHook, this, BEGIN_ADDRESS, END_ADDRESS)); + CHECKED(uc_hook_add(uc, &mem_write_prot_hook, UC_HOOK_MEM_WRITE, (void*)MemoryWriteHook, this, BEGIN_ADDRESS, END_ADDRESS)); +} + +A64Unicorn::~A64Unicorn() { + ClearPageCache(); + CHECKED(uc_hook_del(uc, intr_hook)); + CHECKED(uc_hook_del(uc, mem_invalid_hook)); + CHECKED(uc_close(uc)); +} + +void A64Unicorn::Run() { + while (testenv.ticks_left > 0) { + CHECKED(uc_emu_start(uc, GetPC(), END_ADDRESS, 0, 1)); + testenv.ticks_left--; + if (!testenv.interrupts.empty() || testenv.code_mem_modified_by_guest) { + return; + } + } +} + +u64 A64Unicorn::GetSP() const { + u64 sp; + CHECKED(uc_reg_read(uc, UC_ARM64_REG_SP, &sp)); + return sp; +} +void A64Unicorn::SetSP(u64 value) { + CHECKED(uc_reg_write(uc, UC_ARM64_REG_SP, &value)); +} + +u64 A64Unicorn::GetPC() const { + u64 pc; + CHECKED(uc_reg_read(uc, UC_ARM64_REG_PC, &pc)); + return pc; +} + +void A64Unicorn::SetPC(u64 value) { + CHECKED(uc_reg_write(uc, UC_ARM64_REG_PC, &value)); +} + +constexpr std::array<int, A64Unicorn::num_gprs> gpr_ids{ + UC_ARM64_REG_X0, UC_ARM64_REG_X1, UC_ARM64_REG_X2, UC_ARM64_REG_X3, UC_ARM64_REG_X4, UC_ARM64_REG_X5, UC_ARM64_REG_X6, UC_ARM64_REG_X7, + UC_ARM64_REG_X8, UC_ARM64_REG_X9, UC_ARM64_REG_X10, UC_ARM64_REG_X11, UC_ARM64_REG_X12, UC_ARM64_REG_X13, UC_ARM64_REG_X14, UC_ARM64_REG_X15, + UC_ARM64_REG_X16, UC_ARM64_REG_X17, UC_ARM64_REG_X18, UC_ARM64_REG_X19, UC_ARM64_REG_X20, UC_ARM64_REG_X21, UC_ARM64_REG_X22, UC_ARM64_REG_X23, + UC_ARM64_REG_X24, UC_ARM64_REG_X25, UC_ARM64_REG_X26, UC_ARM64_REG_X27, UC_ARM64_REG_X28, UC_ARM64_REG_X29, UC_ARM64_REG_X30}; + +A64Unicorn::RegisterArray A64Unicorn::GetRegisters() const { + RegisterArray regs{}; + RegisterPtrArray ptrs; + for (size_t i = 0; i < ptrs.size(); ++i) + ptrs[i] = ®s[i]; + + CHECKED(uc_reg_read_batch(uc, const_cast<int*>(gpr_ids.data()), + reinterpret_cast<void**>(ptrs.data()), static_cast<int>(num_gprs))); + return regs; +} + +void A64Unicorn::SetRegisters(const RegisterArray& value) { + RegisterConstPtrArray ptrs; + for (size_t i = 0; i < ptrs.size(); ++i) + ptrs[i] = &value[i]; + + CHECKED(uc_reg_write_batch(uc, const_cast<int*>(gpr_ids.data()), + reinterpret_cast<void**>(const_cast<u64**>(ptrs.data())), static_cast<int>(num_gprs))); +} + +constexpr std::array<int, A64Unicorn::num_vecs> vec_ids{ + UC_ARM64_REG_Q0, UC_ARM64_REG_Q1, UC_ARM64_REG_Q2, UC_ARM64_REG_Q3, UC_ARM64_REG_Q4, UC_ARM64_REG_Q5, UC_ARM64_REG_Q6, UC_ARM64_REG_Q7, + UC_ARM64_REG_Q8, UC_ARM64_REG_Q9, UC_ARM64_REG_Q10, UC_ARM64_REG_Q11, UC_ARM64_REG_Q12, UC_ARM64_REG_Q13, UC_ARM64_REG_Q14, UC_ARM64_REG_Q15, + UC_ARM64_REG_Q16, UC_ARM64_REG_Q17, UC_ARM64_REG_Q18, UC_ARM64_REG_Q19, UC_ARM64_REG_Q20, UC_ARM64_REG_Q21, UC_ARM64_REG_Q22, UC_ARM64_REG_Q23, + UC_ARM64_REG_Q24, UC_ARM64_REG_Q25, UC_ARM64_REG_Q26, UC_ARM64_REG_Q27, UC_ARM64_REG_Q28, UC_ARM64_REG_Q29, UC_ARM64_REG_Q30, UC_ARM64_REG_Q31}; + +A64Unicorn::VectorArray A64Unicorn::GetVectors() const { + VectorArray vecs{}; + VectorPtrArray ptrs; + for (size_t i = 0; i < ptrs.size(); ++i) + ptrs[i] = &vecs[i]; + + CHECKED(uc_reg_read_batch(uc, const_cast<int*>(vec_ids.data()), + reinterpret_cast<void**>(ptrs.data()), static_cast<int>(num_vecs))); + + return vecs; +} + +void A64Unicorn::SetVectors(const VectorArray& value) { + VectorConstPtrArray ptrs; + for (size_t i = 0; i < ptrs.size(); ++i) + ptrs[i] = &value[i]; + + CHECKED(uc_reg_write_batch(uc, const_cast<int*>(vec_ids.data()), + reinterpret_cast<void* const*>(const_cast<Vector**>(ptrs.data())), static_cast<int>(num_vecs))); +} + +u32 A64Unicorn::GetFpcr() const { + u32 fpcr; + CHECKED(uc_reg_read(uc, UC_ARM64_REG_FPCR, &fpcr)); + return fpcr; +} + +void A64Unicorn::SetFpcr(u32 value) { + CHECKED(uc_reg_write(uc, UC_ARM64_REG_FPCR, &value)); +} + +u32 A64Unicorn::GetFpsr() const { + u32 fpsr; + CHECKED(uc_reg_read(uc, UC_ARM64_REG_FPSR, &fpsr)); + return fpsr; +} + +void A64Unicorn::SetFpsr(u32 value) { + CHECKED(uc_reg_write(uc, UC_ARM64_REG_FPSR, &value)); +} + +u32 A64Unicorn::GetPstate() const { + u32 pstate; + CHECKED(uc_reg_read(uc, UC_ARM64_REG_NZCV, &pstate)); + return pstate; +} + +void A64Unicorn::SetPstate(u32 value) { + CHECKED(uc_reg_write(uc, UC_ARM64_REG_NZCV, &value)); +} + +void A64Unicorn::ClearPageCache() { + for (const auto& page : pages) { + CHECKED(uc_mem_unmap(uc, page->address, 4096)); + } + pages.clear(); +} + +void A64Unicorn::DumpMemoryInformation() { + uc_mem_region* regions; + u32 count; + CHECKED(uc_mem_regions(uc, ®ions, &count)); + + for (u32 i = 0; i < count; ++i) { + printf("region: start 0x%016" PRIx64 " end 0x%016" PRIx64 " perms 0x%08x\n", regions[i].begin, regions[i].end, regions[i].perms); + } + + CHECKED(uc_free(regions)); +} + +void A64Unicorn::InterruptHook(uc_engine* uc, u32 int_number, void* user_data) { + auto* this_ = static_cast<A64Unicorn*>(user_data); + + u32 esr; + CHECKED(uc_reg_read(uc, UC_ARM64_REG_ESR, &esr)); + + auto ec = esr >> 26; + auto iss = esr & 0xFFFFFF; + + switch (ec) { + case 0x15: // SVC + this_->testenv.CallSVC(iss); + break; + default: + this_->testenv.interrupts.emplace_back(fmt::format("Unhandled interrupt: int_number: {:#x}, esr: {:#x} (ec: {:#x}, iss: {:#x})", int_number, esr, ec, iss)); + break; + } +} + +bool A64Unicorn::UnmappedMemoryHook(uc_engine* uc, uc_mem_type /*type*/, u64 start_address, int size, u64 /*value*/, void* user_data) { + auto* this_ = static_cast<A64Unicorn*>(user_data); + + const auto generate_page = [&](u64 base_address) { + // printf("generate_page(%" PRIx64 ")\n", base_address); + + const u32 permissions = [&]() -> u32 { + if (base_address < this_->testenv.code_mem.size() * 4) + return UC_PROT_READ | UC_PROT_EXEC; + return UC_PROT_READ; + }(); + + auto page = std::make_unique<Page>(); + page->address = base_address; + for (size_t i = 0; i < page->data.size(); ++i) + page->data[i] = this_->testenv.MemoryRead8(base_address + i); + + uc_err err = uc_mem_map_ptr(uc, base_address, page->data.size(), permissions, page->data.data()); + if (err == UC_ERR_MAP) + return; // page already exists + CHECKED(err); + + this_->pages.emplace_back(std::move(page)); + }; + + const auto is_in_range = [](u64 addr, u64 start, u64 end) { + if (start <= end) + return addr >= start && addr <= end; // fffff[tttttt]fffff + return addr >= start || addr <= end; // ttttt]ffffff[ttttt + }; + + const u64 start_address_page = start_address & ~u64(0xFFF); + const u64 end_address = start_address + size - 1; + + u64 current_address = start_address_page; + do { + generate_page(current_address); + current_address += 0x1000; + } while (is_in_range(current_address, start_address_page, end_address) && current_address != start_address_page); + + return true; +} + +bool A64Unicorn::MemoryWriteHook(uc_engine* /*uc*/, uc_mem_type /*type*/, u64 start_address, int size, u64 value, void* user_data) { + auto* this_ = static_cast<A64Unicorn*>(user_data); + + switch (size) { + case 1: + this_->testenv.MemoryWrite8(start_address, static_cast<u8>(value)); + break; + case 2: + this_->testenv.MemoryWrite16(start_address, static_cast<u16>(value)); + break; + case 4: + this_->testenv.MemoryWrite32(start_address, static_cast<u32>(value)); + break; + case 8: + this_->testenv.MemoryWrite64(start_address, value); + break; + default: + UNREACHABLE(); + } + + return true; +} diff --git a/externals/dynarmic/tests/unicorn_emu/a64_unicorn.h b/externals/dynarmic/tests/unicorn_emu/a64_unicorn.h new file mode 100644 index 0000000000..57759605f0 --- /dev/null +++ b/externals/dynarmic/tests/unicorn_emu/a64_unicorn.h @@ -0,0 +1,82 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2018 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#pragma once + +#include <array> +#include <vector> + +#ifdef _MSC_VER +# pragma warning(push, 0) +# include <unicorn/unicorn.h> +# pragma warning(pop) +#else +# include <unicorn/unicorn.h> +#endif + +#include <mcl/stdint.hpp> + +#include "../A64/testenv.h" + +class A64Unicorn final { +public: + static constexpr size_t num_gprs = 31; + using RegisterArray = std::array<u64, num_gprs>; + using RegisterPtrArray = std::array<RegisterArray::pointer, num_gprs>; + using RegisterConstPtrArray = std::array<RegisterArray::const_pointer, num_gprs>; + + static constexpr size_t num_vecs = 32; + using VectorArray = std::array<Vector, num_vecs>; + using VectorPtrArray = std::array<VectorArray::pointer, num_vecs>; + using VectorConstPtrArray = std::array<VectorArray::const_pointer, num_vecs>; + + explicit A64Unicorn(A64TestEnv& testenv); + ~A64Unicorn(); + + void Run(); + + u64 GetSP() const; + void SetSP(u64 value); + + u64 GetPC() const; + void SetPC(u64 value); + + RegisterArray GetRegisters() const; + void SetRegisters(const RegisterArray& value); + + VectorArray GetVectors() const; + void SetVectors(const VectorArray& value); + + u32 GetFpcr() const; + void SetFpcr(u32 value); + + u32 GetFpsr() const; + void SetFpsr(u32 value); + + u32 GetPstate() const; + void SetPstate(u32 value); + + void ClearPageCache(); + + void DumpMemoryInformation(); + +private: + static void InterruptHook(uc_engine* uc, u32 interrupt, void* user_data); + static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int size, u64 value, void* user_data); + static bool MemoryWriteHook(uc_engine* uc, uc_mem_type type, u64 addr, int size, u64 value, void* user_data); + + struct Page { + u64 address; + std::array<u8, 4096> data; + }; + + A64TestEnv& testenv; + uc_engine* uc{}; + uc_hook intr_hook{}; + uc_hook mem_invalid_hook{}; + uc_hook mem_write_prot_hook{}; + + std::vector<std::unique_ptr<Page>> pages; +}; diff --git a/externals/dynarmic/tests/x64_cpu_info.cpp b/externals/dynarmic/tests/x64_cpu_info.cpp new file mode 100644 index 0000000000..8e67f0fc39 --- /dev/null +++ b/externals/dynarmic/tests/x64_cpu_info.cpp @@ -0,0 +1,119 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2020 MerryMage + * SPDX-License-Identifier: 0BSD + */ + +#include <array> +#include <cstddef> +#include <cstdint> +#include <cstdio> +#include <cstring> +#include <utility> + +#include <catch2/catch_test_macros.hpp> +#include <xbyak/xbyak_util.h> + +TEST_CASE("Host CPU supports", "[a64]") { + using Cpu = Xbyak::util::Cpu; + Cpu cpu_info; + + std::array<std::uint32_t, 4> cpu_name; + for (std::uint32_t i = 2; i < 5; ++i) { + cpu_info.getCpuid(0x80000000 | i, cpu_name.data()); + std::printf("%.16s", reinterpret_cast<const char*>(cpu_name.data())); + } + std::putchar('\n'); + + cpu_info.putFamily(); + const std::array types{ +#define X(NAME) std::make_pair(Cpu::Type{Cpu::NAME}, &#NAME[1]) + X(t3DN), + X(tADX), + X(tAESNI), + X(tAMD), + X(tAMX_BF16), + X(tAMX_INT8), + X(tAMX_TILE), + X(tAVX), + X(tAVX2), + X(tAVX512_4FMAPS), + X(tAVX512_4VNNIW), + X(tAVX512_BF16), + X(tAVX512_BITALG), + X(tAVX512_FP16), + X(tAVX512_IFMA), + X(tAVX512_VBMI), + X(tAVX512_VBMI2), + X(tAVX512_VNNI), + X(tAVX512_VP2INTERSECT), + X(tAVX512_VPOPCNTDQ), + X(tAVX512BW), + X(tAVX512CD), + X(tAVX512DQ), + X(tAVX512ER), + X(tAVX512F), + X(tAVX512IFMA), + X(tAVX512PF), + X(tAVX512VBMI), + X(tAVX512VL), + X(tAVX_VNNI), + X(tBMI1), + X(tBMI2), + X(tCLDEMOTE), + X(tCLFLUSHOPT), + X(tCLZERO), + X(tCMOV), + X(tE3DN), + X(tENHANCED_REP), + X(tF16C), + X(tFMA), + X(tGFNI), + X(tHLE), + X(tINTEL), + X(tLZCNT), + X(tMMX), + X(tMMX2), + X(tMOVBE), + X(tMOVDIR64B), + X(tMOVDIRI), + X(tMPX), + X(tOSXSAVE), + X(tPCLMULQDQ), + X(tPOPCNT), + X(tPREFETCHW), + X(tPREFETCHWT1), + X(tRDRAND), + X(tRDSEED), + X(tRDTSCP), + X(tRTM), + X(tSHA), + X(tSMAP), + X(tSSE), + X(tSSE2), + X(tSSE3), + X(tSSE41), + X(tSSE42), + X(tSSSE3), + X(tVAES), + X(tVPCLMULQDQ), + X(tWAITPKG), +#undef X + }; + + constexpr std::size_t line_max = 80; + std::size_t line_length = 0; + for (const auto& [type, name] : types) { + if (cpu_info.has(type)) { + const std::size_t name_length = std::strlen(name) + 1; + if ((line_length + name_length) >= line_max) { + line_length = name_length; + std::putchar('\n'); + } else if (line_length) { + std::putchar(' '); + } + std::fputs(name, stdout); + line_length += name_length; + } + } + std::putchar('\n'); +} |