diff --git a/CMakeLists.txt b/CMakeLists.txt index b83215e744..efb105598d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -101,14 +101,6 @@ set_property( CACHE FIN_BACKEND PROPERTY STRINGS # HIP is always required find_package(hip REQUIRED PATHS /opt/rocm) find_package(rocblas REQUIRED PATHS /opt/rocm) -# probably not required -target_flags(HIP_COMPILER_FLAGS hip::device) -# Remove cuda arch flags -string(REGEX REPLACE --cuda-gpu-arch=[a-z0-9]+ "" HIP_COMPILER_FLAGS "${HIP_COMPILER_FLAGS}") - -message(STATUS "Hip compiler flags: ${HIP_COMPILER_FLAGS}") - -add_definitions("-DHIP_COMPILER_FLAGS=${HIP_COMPILER_FLAGS}") # OpenCL 1.2 if( FIN_BACKEND STREQUAL "OpenCL") @@ -208,6 +200,8 @@ elseif(FIN_BACKEND STREQUAL "HIP") set(MIOPEN_TIDY_ERRORS ALL) endif() +if(NOT MIOPEN_ENABLE_FIN) + message("MIOPEN_ENABLE_FIN is NOT SET") include(ClangTidy) enable_clang_tidy( CHECKS @@ -329,6 +323,9 @@ enable_cppcheck( MIOPEN_USE_MIOPENGEMM=1 __linux__=1 ) +else() + message("MIOPEN_ENABLE_FIN is SET") +endif() set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib) diff --git a/Dockerfile b/Dockerfile index 723f52e803..6b6626ffe1 100644 --- a/Dockerfile +++ b/Dockerfile @@ -8,7 +8,12 @@ RUN dpkg --add-architecture i386 # Add rocm repository RUN apt-get update RUN DEBIAN_FRONTEND=noninteractive apt-get install -y curl apt-utils wget gnupg2 -RUN curl https://raw.githubusercontent.com/RadeonOpenCompute/ROCm-docker/master/add-rocm.sh | bash + +#RUN curl https://raw.githubusercontent.com/RadeonOpenCompute/ROCm-docker/master/add-rocm.sh | bash +ARG ROCMVERSION=4.5 +ARG DEB_ROCM_REPO=http://repo.radeon.com/rocm/apt/.apt_$ROCMVERSION/ +RUN wget -qO - http://repo.radeon.com/rocm/rocm.gpg.key | apt-key add - +RUN sh -c "echo deb [arch=amd64] $DEB_ROCM_REPO ubuntu main > /etc/apt/sources.list.d/rocm.list" # Install dependencies required to build hcc # Ubuntu csomic contains llvm-7 required to build Tensile diff --git a/requirements.txt b/requirements.txt index 1e6a738892..3dd8bdb0c7 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ RadeonOpenCompute/rocm-cmake@cdd0f632b3a65bd4411593bb827eb664e25c80bc --build # ROCmSoftwarePlatform/MIOpen@9b2d37f9f1e4b5492ef8256cf8168363ca5fd2da -nlohmann/json +nlohmann/json@v3.10.4 #ROCmSoftwarePlatform/rocBLAS@9790a8658341bc665c11c311129ad0dfc533d5c4 diff --git a/src/include/conv_fin.hpp b/src/include/conv_fin.hpp index 7ca262e1da..b367ea6118 100644 --- a/src/include/conv_fin.hpp +++ b/src/include/conv_fin.hpp @@ -73,7 +73,8 @@ namespace fin { -using json = nlohmann::json; +const int INVOKE_LIMIT = 2; +using json = nlohmann::json; // TODO: Create a config class to encapsulate config // related code, such as checking direction etc template @@ -83,23 +84,17 @@ class ConvFin : public Fin ConvFin() : Fin() {} ConvFin(json _job) : Fin(), job(_job) { - VerifyDevProps(); - command = _job["config"]; - command["bias"] = 0; - // timing is always enabled - is_fwd = (_job["direction"].get() == 0 || _job["direction"].get() & 1); - is_bwd = (_job["direction"].get() == 0 || _job["direction"].get() & 2); - is_wrw = (_job["direction"].get() == 0 || _job["direction"].get() & 4); - SetConvDescriptor(); - // workspace_dev = nullptr; // TODO: replaced with a tensor class - // the variable name is implementation dependent, checking size instead + if(job.contains("config")) + PrepConvolution(); } + void VerifyDevProps() { std::cerr << "Verifying device properties" << std::endl; std::string arch = job["arch"]; arch = arch.substr(0, arch.find(':')); const size_t num_cu = job["num_cu"]; + std::ignore = num_cu; if(arch == "gfx900") { assert(num_cu == 56 || num_cu == 64); @@ -116,10 +111,28 @@ class ConvFin : public Fin { assert(num_cu == 72 || num_cu == 36); } + else if(arch == "gfx90a") + { + assert(num_cu == 110 || num_cu == 104); + } else throw std::runtime_error("Invalid Arch Name"); } + void PrepConvolution() + { + VerifyDevProps(); + command = job["config"]; + command["bias"] = 0; + // timing is always enabled + is_fwd = (job["direction"].get() == 0 || job["direction"].get() & 1); + is_bwd = (job["direction"].get() == 0 || job["direction"].get() & 2); + is_wrw = (job["direction"].get() == 0 || job["direction"].get() & 4); + SetConvDescriptor(); + // workspace_dev = nullptr; // TODO: replaced with a tensor class + // the variable name is implementation dependent, checking size instead + } + // Getters and setters std::vector GetInputTensorLengths(); std::vector GetWeightTensorLengths(); @@ -142,10 +155,13 @@ class ConvFin : public Fin int CopyFromDevice(); int RunGPU(); int TestApplicability(); + int TestPerfDbValid(); int GetandSetData(); int GetSolverList(); + int MIOpenPerfCompile(); int MIOpenFind(); int MIOpenFindCompile(); + int MIOpenPerfEval(); int MIOpenFindEval(); // Utility functions @@ -192,6 +208,157 @@ void ConvFin::InitNoGpuHandle(miopen::Handle& handle) std::ignore = handle; #endif } + +template +int ConvFin::MIOpenPerfCompile() +{ + std::cerr << "MIOpenPerfCompile" << std::endl; + std::cerr << "Processing command: " << command << std::endl; +#if MIOPEN_MODE_NOGPU + GetandSetData(); +#else + throw std::runtime_error( + "Unable to perform MIOpenPerfCompile MIOpen was not compiled using HIPNOGPU backend"); +#endif + const auto conv_dir = GetDirection(); + const miopen::ProblemDescription problem( + inputTensor.desc, weightTensor.desc, outputTensor.desc, convDesc, conv_dir); + GetHandle().EnableProfiling(true); + auto ctx = miopen::ConvolutionContext{problem}; + auto handle = miopen::Handle{}; +#if MIOPEN_MODE_NOGPU + InitNoGpuHandle(handle); +#else + throw std::runtime_error("MIOpen needs to be compiled with the NOGPU backend " + "for MIOpenPerfCompile"); +#endif + ctx.SetStream(&handle); + ctx.DetectRocm(); + ctx.SetupFloats(); + + const auto network_config = ctx.BuildConfKey(); + const bool is_winograd_only = convDesc.IsWinograd3x3SupportedAndFast(ctx); + output["is_winograd_only"] = is_winograd_only; + output["network_config"] = network_config; + std::ostringstream ss; + problem.Serialize(ss); + output["db_key"] = ss.str(); + + json perf_result; + const auto& tgt_props = handle.GetTargetProperties(); + const std::string arch = tgt_props.Name(); + const size_t num_cu = handle.GetMaxComputeUnits(); + std::cerr << "Job Arch: " << job["arch"] << ": Handle Arch: " << arch << std::endl; + std::cerr << "Job Num CU: " << job["num_cu"] << ": Handle Num Cu: " << num_cu << std::endl; + std::vector solver_list; + if(job.contains("solvers")) + for(std::string solver_str : job["solvers"]) + solver_list.push_back(miopen::solver::Id(solver_str)); + else + solver_list = miopen::solver::GetSolversByPrimitive(miopen::solver::Primitive::Convolution); + + for(const auto& solver_id : solver_list) + { + json res_item; + // remove the user db files + boost::filesystem::remove_all(miopen::GetCachePath(false)); + auto process_solver = [&]() -> bool { + std::cerr << "Processing Solver: " << solver_id.ToString() << std::endl; + res_item["solver_id"] = solver_id.ToString(); + if(solver_id.ToString() == "ConvBiasActivAsm1x1U" || + solver_id.ToString().find("Fused") != std::string::npos) + { + std::cerr << "Skipping fused solvers" << std::endl; + return false; + } + const auto& s = solver_id.GetSolver(); + const auto algo = solver_id.GetAlgo(conv_dir); + res_item["algorithm"] = algo; + if(s.IsEmpty()) + { + res_item["reason"] = "Empty Solver"; + std::cerr << "Skipping invalid solver: " << solver_id.ToString() << std::endl; + return false; + } + if(!s.IsApplicable(ctx)) + { + res_item["reason"] = "Not Applicable"; + std::cerr << "Skipping inapplicable solver: " << solver_id.ToString() << std::endl; + return false; + } + if(!s.IsTunable()) + { + res_item["reason"] = "Not Tunable"; + std::cerr << "Skipping non-tunable solver: " << solver_id.ToString() << std::endl; + return false; + } + + auto all_solutions = s.GetAllSolutions(ctx); + + // PrecompileKernels call saves to binary_cache, + // this needs to be escaped if KERN_CACHE is not on. + std::vector kernels; + for(const auto& current_solution : all_solutions) + { + for(auto&& kernel : current_solution.construction_params) + { + kernels.push_back(kernel); + } + } + std::ignore = miopen::solver::PrecompileKernels(handle, kernels); + + json kernel_list = json::array(); + for(const auto& k : kernels) + { + json kernel; + auto comp_opts = k.comp_options; + auto p = handle.LoadProgram(k.kernel_file, comp_opts, false, ""); + const auto hsaco = p.IsCodeObjectInMemory() + ? p.GetCodeObjectBlob() + : miopen::LoadFile(p.GetCodeObjectPathname().string()); + if(hsaco.empty()) + { + std::cerr << "Got empty code object" << std::endl; + throw std::runtime_error("Got empty code object"); + } + // Compress the blob + auto md5_sum = miopen::md5(hsaco); + auto size = hsaco.size(); + bool success = false; + auto compressed_hsaco = miopen::compress(hsaco, &success); + const auto encoded_hsaco = base64_encode(compressed_hsaco); + kernel["kernel_file"] = k.kernel_file; + kernel["comp_options"] = k.comp_options; + if(success) + { + kernel["uncompressed_size"] = size; + kernel["md5_sum"] = md5_sum; + kernel["blob"] = encoded_hsaco; + } + else + { + kernel["md5_sum"] = "Failed to compress kernel"; + kernel["uncompressed_size"] = 0; + kernel["blob"] = ""; + } + kernel_list.push_back(kernel); + std::cerr << "Successfully added new kernel" << std::endl; + } + res_item["kernel_objects"] = kernel_list; + return true; + }; + + auto res = process_solver(); + if(res) + { + res_item["perf_compiled"] = res; + perf_result.push_back(res_item); + } + } + output["miopen_perf_compile_result"] = perf_result; + return 1; +} + template int ConvFin::MIOpenFindCompile() { @@ -234,6 +401,9 @@ int ConvFin::MIOpenFindCompile() const size_t num_cu = handle.GetMaxComputeUnits(); std::cerr << "Job Arch: " << job["arch"] << ": Handle Arch: " << arch << std::endl; std::cerr << "Job Num CU: " << job["num_cu"] << ": Handle Num Cu: " << num_cu << std::endl; + bool dynamic_only = false; + if(job.contains("dynamic_only")) + dynamic_only = job["dynamic_only"]; // since applicability has been run, the solver list should come from Tuna for(const auto& solver_id : miopen::solver::GetSolversByPrimitive(miopen::solver::Primitive::Convolution)) @@ -244,7 +414,8 @@ int ConvFin::MIOpenFindCompile() auto process_solver = [&]() -> bool { std::cerr << "Processing Solver: " << solver_id.ToString() << std::endl; res_item["solver_id"] = solver_id.ToString(); - if(res_item["solver_id"] == "ConvBiasActivAsm1x1U") + if(solver_id.ToString() == "ConvBiasActivAsm1x1U" || + solver_id.ToString().find("Fused") != std::string::npos) { std::cerr << "Skipping fused solvers" << std::endl; return false; @@ -264,6 +435,12 @@ int ConvFin::MIOpenFindCompile() std::cerr << "Skipping inapplicable solver: " << solver_id.ToString() << std::endl; return false; } + if(dynamic_only && !s.IsDynamic()) + { + res_item["reason"] = "Not Dynamic"; + std::cerr << "Skipping static solver: " << solver_id.ToString() << std::endl; + return false; + } miopen::solver::ConvSolution solution; try { @@ -277,7 +454,7 @@ int ConvFin::MIOpenFindCompile() return true; } res_item["reason"] = "Success"; - res_item["workspace"] = solution.workspce_sz; + res_item["workspace"] = solution.workspace_sz; // Get the binary json kernel_list = json::array(); for(const auto& k : solution.construction_params) @@ -333,6 +510,246 @@ int ConvFin::MIOpenFindCompile() return 1; } +template +int ConvFin::MIOpenPerfEval() +{ + std::cerr << "MIOpenPerfEval" << std::endl; + std::cerr << "Processing command: " << command << std::endl; +// Before this step is executed, the following steps should have been evaluated +// alloc_buf only if only timing is required +// alloc_buf, fill_buf and copy_buf_to_device if numerical accuracy would be +// checked ?? +#if MIOPEN_MODE_NOGPU + throw std::runtime_error("Unable to run MIOpenPerfEval, Invalid MIOpen backend: HIPNOGPU"); +#endif + const auto conv_dir = GetDirection(); + // The first arg to the DataInvokeParams changes based on direction + const miopen::ProblemDescription problem( + inputTensor.desc, weightTensor.desc, outputTensor.desc, convDesc, conv_dir); + GetHandle().EnableProfiling(true); + auto ctx = miopen::ConvolutionContext{problem}; + auto& h = GetHandle(); + ctx.SetStream(&(h)); + ctx.DetectRocm(); + ctx.SetupFloats(); + + const auto network_config = ctx.BuildConfKey(); + const bool is_winograd_only = convDesc.IsWinograd3x3SupportedAndFast(ctx); + output["is_winograd_only"] = is_winograd_only; + output["network_config"] = network_config; + std::ostringstream ss; + problem.Serialize(ss); + output["db_key"] = ss.str(); + + auto db = GetDb(ctx); + json perf_result; + const auto& tgt_props = h.GetTargetProperties(); + const std::string arch = tgt_props.Name(); + const size_t num_cu = h.GetMaxComputeUnits(); + std::cerr << "Job Arch: " << job["arch"] << ": Handle Arch: " << arch << std::endl; + std::cerr << "Job Num CU: " << job["num_cu"] << ": Handle Num Cu: " << num_cu << std::endl; + for(const auto& kinder : + job["miopen_perf_compile_result"]) // The "miopen_perf_compile_result" list generated + // by miopen_perf_compile operation + { + // Somehow the direction changes mid loop ! + json res_item; + boost::system::error_code ec; + boost::filesystem::remove_all(miopen::GetCachePath(false), ec); + // boost::filesystem::remove_all(miopen::GetCachePath(true), ec); + if(ec) + { + std::cerr << "Error while removing MIOpen cache: " << ec.message(); + } + auto process_solver = [&]() -> bool { + const std::string solver_name = kinder["solver_id"]; + std::cerr << "Processing solver: " << solver_name << std::endl; + const auto solver_id = miopen::solver::Id{solver_name}; + const auto& s = solver_id.GetSolver(); + res_item["solver_name"] = solver_name; + const auto algo = solver_id.GetAlgo(conv_dir); + res_item["algorithm"] = algo; + std::string params = ""; + + if(s.IsEmpty()) + { + std::cerr << "Skipping invalid solver: " << solver_id.ToString() << std::endl; + return false; + } + if(!s.IsApplicable(ctx)) + { + std::cerr << "Solver inapplicable: " << solver_name << std::endl; + throw std::runtime_error( + "InApplicable solver was sent to fin, check Tuna for errors"); + return false; + } + if(!s.IsTunable()) + { + std::cerr << "Skipping non-tunable solver: " << solver_id.ToString() << std::endl; + return false; + } + + std::cerr << solver_name << " is applicable" << std::endl; + miopen::solver::ConvSolution solution; + solution = s.FindSolution(ctx, db, {}); // auto tune is not expected here + res_item["workspace"] = solution.workspace_sz; + // Get the binary + std::cerr << "loading binaries from fin input" << std::endl; + for(const auto& kernel_obj : kinder["kernel_objects"]) + { + const auto size = kernel_obj["uncompressed_size"]; + const auto md5_sum = kernel_obj["md5_sum"]; + const auto encoded_hsaco = kernel_obj["blob"]; + const auto decoded_hsaco = base64_decode(encoded_hsaco); + const auto hsaco = miopen::decompress(decoded_hsaco, size); + std::string comp_opts = kernel_obj["comp_options"]; + std::string kernel_file = kernel_obj["kernel_file"]; + if(miopen::md5(hsaco) == md5_sum) + { + auto p = miopen::Program{kernel_file, hsaco}; + h.AddProgram(p, kernel_file, comp_opts); + } + else + { + std::cerr << "Corrupt Binary Object" << std::endl; + throw std::runtime_error("Corrupt binary object"); + return false; + } + } + + for(const auto& kern : solution.construction_params) + { + if(!h.HasProgram(kern.kernel_file, kern.comp_options)) + { + std::cerr << "Binary object check failed, either tuning params have changed or " + "fin is unable to write binary to program cache" + << std::endl; + } + } + std::cerr << "Checking for workspace" << std::endl; + if(solution.workspace_sz > workspace.desc.GetNumBytes()) + { + std::cerr << "Allocating " << solution.workspace_sz << " bytes for workspace" + << std::endl; + workspace = tensor{ + q, + std::vector{static_cast(solution.workspace_sz / sizeof(Tgpu))}, + false, + false}; + workspace.AllocateBuffers(); + } + if(!solution.invoker_factory) + { + std::cerr << "Invoker not implemeted" << std::endl; + res_item["reason"] = "Invoker not implemented"; + return false; + } + + try + { + float time = 0.0f; + ctx.do_search = true; + ctx.db_update = true; + + // This is required because DataInvokeParams switches tensor order due to + // direction and it does not have a + // copy constructor or a default constructor + if(conv_dir == miopen::conv::Direction::Forward) + { + const auto invoke_ctx = + miopen::conv::DataInvokeParams{{inputTensor.desc, + inputTensor.gpuData.buf.get(), + weightTensor.desc, + weightTensor.gpuData.buf.get(), + outputTensor.desc, + outputTensor.gpuData.buf.get()}, + workspace.gpuData.buf.get(), + workspace.desc.GetNumBytes(), + convDesc.attribute.gfx90aFp16alt.GetFwd()}; + + solution = s.FindSolution(ctx, db, invoke_ctx); // forcing search here + params = s.GetPerfCfgParams(ctx, db); + + const auto invoker = + h.PrepareInvoker(*solution.invoker_factory, solution.construction_params); + invoker(h, invoke_ctx); + time = h.GetKernelTime(); + } + else if(conv_dir == miopen::conv::Direction::BackwardData) + { + const auto invoke_ctx = + miopen::conv::DataInvokeParams{{outputTensor.desc, + outputTensor.gpuData.buf.get(), + weightTensor.desc, + weightTensor.gpuData.buf.get(), + inputTensor.desc, + inputTensor.gpuData.buf.get()}, + workspace.gpuData.buf.get(), + workspace.desc.GetNumBytes(), + convDesc.attribute.gfx90aFp16alt.GetBwd()}; + + solution = s.FindSolution(ctx, db, invoke_ctx); // forcing search here + params = s.GetPerfCfgParams(ctx, db); + + const auto invoker = + h.PrepareInvoker(*solution.invoker_factory, solution.construction_params); + invoker(h, invoke_ctx); + time = h.GetKernelTime(); + } + else if(conv_dir == miopen::conv::Direction::BackwardWeights) + { + const auto invoke_ctx = + miopen::conv::WrWInvokeParams{{outputTensor.desc, + outputTensor.gpuData.buf.get(), + inputTensor.desc, + inputTensor.gpuData.buf.get(), + weightTensor.desc, + weightTensor.gpuData.buf.get()}, + workspace.gpuData.buf.get(), + workspace.desc.GetNumBytes(), + convDesc.attribute.gfx90aFp16alt.GetWrW()}; + + solution = s.FindSolution(ctx, db, invoke_ctx); // forcing search here + params = s.GetPerfCfgParams(ctx, db); + + const auto invoker = + h.PrepareInvoker(*solution.invoker_factory, solution.construction_params); + invoker(h, invoke_ctx); + time = h.GetKernelTime(); + } + else + { + ss.str(""); + ss << "Invalid Direction: solver " << solver_name << ", dir " + << static_cast(conv_dir); + throw std::runtime_error(ss.str()); + } + + res_item["params"] = params; + res_item["time"] = time; + res_item["layout"] = ctx.in_layout; + res_item["data_type"] = ctx.in_data_type; + res_item["direction"] = conv_dir; + res_item["bias"] = ctx.bias; + res_item["reason"] = "Success"; + } + catch(const std::exception& e) + { + res_item["reason"] = std::string("Invoker exeception: ") + e.what(); + return false; + } + + return true; + }; + + auto res = process_solver(); + res_item["evaluated"] = res; + perf_result.push_back(res_item); + } + output["miopen_perf_eval_result"] = perf_result; + return 1; +} + template int ConvFin::MIOpenFindEval() { @@ -371,6 +788,9 @@ int ConvFin::MIOpenFindEval() const size_t num_cu = h.GetMaxComputeUnits(); std::cerr << "Job Arch: " << job["arch"] << ": Handle Arch: " << arch << std::endl; std::cerr << "Job Num CU: " << job["num_cu"] << ": Handle Num Cu: " << num_cu << std::endl; + bool dynamic_only = false; + if(job.contains("dynamic_only")) + dynamic_only = job["dynamic_only"]; for(const auto& kinder : job["miopen_find_compile_result"]) // The "miopen_find_compile_result" list generated // by miopen_find_compile operation @@ -404,9 +824,15 @@ int ConvFin::MIOpenFindEval() "InApplicable solver was sent to fin, check Tuna for errors"); return false; } + if(dynamic_only && !s.IsDynamic()) + { + res_item["reason"] = "Not Dynamic"; + std::cerr << "Skipping static solver: " << solver_id.ToString() << std::endl; + return false; + } std::cerr << solver_name << " is applicable" << std::endl; const auto solution = s.FindSolution(ctx, db, {}); // auto tune is not expected here - res_item["workspace"] = solution.workspce_sz; + res_item["workspace"] = solution.workspace_sz; // Get the binary std::cerr << "loading binaries from fin input" << std::endl; for(const auto& kernel_obj : kinder["kernel_objects"]) @@ -440,13 +866,13 @@ int ConvFin::MIOpenFindEval() } } std::cerr << "Checking for workspace" << std::endl; - if(solution.workspce_sz > workspace.desc.GetNumBytes()) + if(solution.workspace_sz > workspace.desc.GetNumBytes()) { - std::cerr << "Allocating " << solution.workspce_sz << " bytes for workspace" + std::cerr << "Allocating " << solution.workspace_sz << " bytes for workspace" << std::endl; workspace = tensor{ q, - std::vector{static_cast(solution.workspce_sz / sizeof(Tgpu))}, + std::vector{static_cast(solution.workspace_sz / sizeof(Tgpu))}, false, false}; workspace.AllocateBuffers(); @@ -476,8 +902,10 @@ int ConvFin::MIOpenFindEval() outputTensor.desc, outputTensor.gpuData.buf.get()}, workspace.gpuData.buf.get(), - workspace.desc.GetNumBytes()}; - invoker(h, invoke_ctx); + workspace.desc.GetNumBytes(), + convDesc.attribute.gfx90aFp16alt.GetFwd()}; + for(auto idx = 0; idx < INVOKE_LIMIT; idx++) + invoker(h, invoke_ctx); } else if(conv_dir == miopen::conv::Direction::BackwardData) { @@ -489,8 +917,10 @@ int ConvFin::MIOpenFindEval() inputTensor.desc, inputTensor.gpuData.buf.get()}, workspace.gpuData.buf.get(), - workspace.desc.GetNumBytes()}; - invoker(h, invoke_ctx); + workspace.desc.GetNumBytes(), + convDesc.attribute.gfx90aFp16alt.GetBwd()}; + for(auto idx = 0; idx < INVOKE_LIMIT; idx++) + invoker(h, invoke_ctx); } else if(conv_dir == miopen::conv::Direction::BackwardWeights) { @@ -502,8 +932,10 @@ int ConvFin::MIOpenFindEval() weightTensor.desc, weightTensor.gpuData.buf.get()}, workspace.gpuData.buf.get(), - workspace.desc.GetNumBytes()}; - invoker(h, invoke_ctx); + workspace.desc.GetNumBytes(), + convDesc.attribute.gfx90aFp16alt.GetWrW()}; + for(auto idx = 0; idx < INVOKE_LIMIT; idx++) + invoker(h, invoke_ctx); } else { @@ -520,7 +952,6 @@ int ConvFin::MIOpenFindEval() res_item["reason"] = "Success"; return true; - }; auto res = process_solver(); @@ -600,7 +1031,7 @@ int ConvFin::MIOpenFind() return false; } const auto solution = s.FindSolution(ctx, db, {}); // auto tune is not expected here - res_item["workspace"] = solution.workspce_sz; + res_item["workspace"] = solution.workspace_sz; // Get the binary miopen::solver::PrecompileKernels(h, solution.construction_params); json kernel_list = json::array(); @@ -632,7 +1063,7 @@ int ConvFin::MIOpenFind() kernel_list.push_back(kernel); } res_item["kernel_objects"] = kernel_list; - if(solution.workspce_sz > workspace.desc.GetNumBytes()) + if(solution.workspace_sz > workspace.desc.GetNumBytes()) { res_item["reason"] = "Insufficient Workspace"; return false; @@ -659,8 +1090,10 @@ int ConvFin::MIOpenFind() outputTensor.desc, outputTensor.gpuData.buf.get()}, workspace.gpuData.buf.get(), - workspace.desc.GetNumBytes()}; - invoker(h, invoke_ctx); + workspace.desc.GetNumBytes(), + convDesc.attribute.gfx90aFp16alt.GetFwd()}; + for(auto idx = 0; idx < INVOKE_LIMIT; idx++) + invoker(h, invoke_ctx); } else if(conv_dir == miopen::conv::Direction::BackwardData) { @@ -672,8 +1105,10 @@ int ConvFin::MIOpenFind() inputTensor.desc, inputTensor.gpuData.buf.get()}, workspace.gpuData.buf.get(), - workspace.desc.GetNumBytes()}; - invoker(h, invoke_ctx); + workspace.desc.GetNumBytes(), + convDesc.attribute.gfx90aFp16alt.GetBwd()}; + for(auto idx = 0; idx < INVOKE_LIMIT; idx++) + invoker(h, invoke_ctx); } else if(conv_dir == miopen::conv::Direction::BackwardWeights) { @@ -685,8 +1120,10 @@ int ConvFin::MIOpenFind() weightTensor.desc, weightTensor.gpuData.buf.get()}, workspace.gpuData.buf.get(), - workspace.desc.GetNumBytes()}; - invoker(h, invoke_ctx); + workspace.desc.GetNumBytes(), + convDesc.attribute.gfx90aFp16alt.GetWrW()}; + for(auto idx = 0; idx < INVOKE_LIMIT; idx++) + invoker(h, invoke_ctx); } else { @@ -703,7 +1140,6 @@ int ConvFin::MIOpenFind() res_item["reason"] = "Success"; return true; - }; auto res = process_solver(); @@ -770,14 +1206,147 @@ int ConvFin::TestApplicability() return 0; } +class ParamString +{ + std::string values; + + public: + ParamString() {} + ParamString(std::string in_val) : values(in_val) {} + + void Serialize(std::ostream& stream) const { stream << values; } + bool Deserialize(const std::string& s) + { + values = s; + return true; + } +}; + +template +int ConvFin::TestPerfDbValid() +{ + bool ret = true; + namespace fs = boost::filesystem; + std::cout << miopen::GetSystemDbPath() << std::endl; + + std::vector contents; + std::copy(fs::directory_iterator(miopen::GetSystemDbPath()), + fs::directory_iterator(), + std::back_inserter(contents)); + for(auto const& db_file : contents) + { + std::string pathstr = db_file.native(); + std::string filestr = db_file.filename().native(); + + if(job["arch"].size() > 0 and job["num_cu"].size() > 0) + { + std::string arch = job["arch"]; + int num_cu = job["num_cu"]; + std::stringstream db_name; + db_name << arch; + if(num_cu > 64) + db_name << std::hex << num_cu << ".db"; + else + db_name << "_" << num_cu << ".db"; + + if(filestr.compare(db_name.str()) != 0) + continue; + } + + if(pathstr.compare(pathstr.size() - 3, 3, ".db") != 0) + continue; + + std::cout << pathstr << "/" << filestr << std::endl; + + auto sql = miopen::SQLite{pathstr, true}; + + // pull out records for all configs from perf_db + std::unordered_map> records; + std::map> perfdb_entries; + std::vector> err_list; + auto select_query = "SELECT config, solver, params, id FROM perf_db;"; + auto stmt = miopen::SQLite::Statement{sql, select_query}; + while(true) + { + auto rc = stmt.Step(sql); + if(rc == SQLITE_ROW) + { + const auto config_id = stmt.ColumnText(0); + const auto solver_id = stmt.ColumnText(1); + const auto params = stmt.ColumnText(2); + const auto perf_id = stmt.ColumnText(3); + records[config_id][solver_id].SetValues(solver_id, ParamString(params)); + perfdb_entries[perf_id]["config"] = config_id; + perfdb_entries[perf_id]["solver"] = solver_id; + } + else if(rc == SQLITE_DONE) + break; + else if(rc == SQLITE_ERROR || rc == SQLITE_MISUSE) + MIOPEN_THROW(miopenStatusInternalError, sql.ErrorMessage()); + } + + // iterate through each config + for(auto it = perfdb_entries.begin(); it != perfdb_entries.end(); it++) + { + auto solver_nm = it->second["solver"]; + auto config_id = it->second["config"]; + auto record = records.find(config_id)->second.find(solver_nm)->second; + + auto slv_id = miopen::solver::Id(solver_nm); + if(!slv_id.IsValid()) + { + std::map err; + err["perfdb_id"] = it->first; + err["config"] = config_id; + err["solver"] = solver_nm; + err_list.push_back(err); + ret = false; + continue; + } + + auto solver = slv_id.GetSolver(); + + // check if the params in the record deserialize + if(!solver.TestSysDbRecord(record)) + { + std::map err; + err["perfdb_id"] = it->first; + err["config"] = config_id; + err["solver"] = solver_nm; + err_list.push_back(err); + ret = false; + } + } + std::string listing = filestr + "_errors"; + output[listing] = err_list; + } + + if(ret) + output["clear"] = "true"; + + return ret; +} + template int ConvFin::GetSolverList() { // pair.first = id, pair. second = string id - std::vector> solvers; + std::vector> solvers; for(const auto& id : miopen::solver::GetSolversByPrimitive(miopen::solver::Primitive::Convolution)) - solvers.push_back(std::make_pair(id.Value(), id.ToString())); + { + std::unordered_map solver; + solver["id"] = std::to_string(id.Value()); + solver["name"] = id.ToString(); + solver["tunable"] = "0"; + solver["dynamic"] = "0"; + if(id.GetSolver().IsTunable()) + solver["tunable"] = "1"; + if(id.GetSolver().IsDynamic()) + solver["dynamic"] = "1"; + solvers.push_back(solver); + } + output["all_solvers"] = solvers; return 0; } @@ -837,12 +1406,18 @@ int ConvFin::ProcessStep(const std::string& step_name) return CopyFromDevice(); if(step_name == "applicability") return TestApplicability(); + if(step_name == "perf_db_test") + return TestPerfDbValid(); if(step_name == "get_solvers") return GetSolverList(); + if(step_name == "miopen_perf_compile") + return MIOpenPerfCompile(); if(step_name == "miopen_find") return MIOpenFind(); if(step_name == "miopen_find_compile") return MIOpenFindCompile(); + if(step_name == "miopen_perf_eval") + return MIOpenPerfEval(); if(step_name == "miopen_find_eval") return MIOpenFindEval(); return 0; @@ -1082,7 +1657,7 @@ int ConvFin::SetConvDescriptor() exit(0); } - miopenPaddingMode_t p_mode = miopenPaddingSame; + miopenPaddingMode_t p_mode = miopenPaddingDefault; if((command["pad_mode"]) == "same") p_mode = miopenPaddingSame; else if((command["pad_mode"]) == "valid") diff --git a/src/include/error.hpp b/src/include/error.hpp index 0279019964..8ba99b1ec4 100644 --- a/src/include/error.hpp +++ b/src/include/error.hpp @@ -19,7 +19,7 @@ struct Exception : std::exception const char* what() const noexcept override { return message.c_str(); } }; -} +} // namespace fin #define FIN_THROW(...) \ do \ { \ diff --git a/src/main.cpp b/src/main.cpp index 0994a33363..5952056f6a 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -60,8 +60,6 @@ using json = nlohmann::json; int main(int argc, char* argv[], char* envp[]) { std::vector args(argv, argv + argc); - std::string ifile; - std::string ofile; std::map MapInputs = {}; for(auto& arg : args) @@ -91,7 +89,6 @@ int main(int argc, char* argv[], char* envp[]) } if(args[i] == "-o") { - ofile = args[i + 1]; MapInputs[args[i].back()] = args[i + 1]; } } @@ -101,13 +98,22 @@ int main(int argc, char* argv[], char* envp[]) // The JSON is a list of commands, so we iterate over the list and then // process each map - std::ifstream i(input_filename.string()); + std::ifstream input_file(input_filename.string()); + if(!input_file) + { + + throw std::runtime_error("Error loading json file: " + input_filename.string()); + } // TODO: fix the output writing so that interim results are not lost if one of // the iterations crash - std::ofstream o(output_filename.string()); + std::ofstream output_file(output_filename.string()); + if(!output_file) + { + throw std::runtime_error("Error opening json file: " + output_filename.string()); + } json j; // = json::parse(cmd); - i >> j; - i.close(); + input_file >> j; + input_file.close(); json final_output; // Get the process env std::vector jenv; @@ -120,22 +126,22 @@ int main(int argc, char* argv[], char* envp[]) // process through the jobs for(auto& it : j) { - auto command = it; - fin::Fin* f = nullptr; + auto command = it; + std::unique_ptr f = nullptr; // TODO : Move this to a factory function if(command.contains("config")) { if(command["config"]["cmd"] == "conv") { - f = new fin::ConvFin(command); + f = std::make_unique>(command); } else if(command["config"]["cmd"] == "convfp16") { - f = new fin::ConvFin(command); + f = std::make_unique>(command); } else if(command["config"]["cmd"] == "convbfp16") { - f = new fin::ConvFin(command); + f = std::make_unique>(command); } else { @@ -143,9 +149,13 @@ int main(int argc, char* argv[], char* envp[]) exit(-1); } } + else if(command.contains("pdb_verif") and command["pdb_verif"] == true) + { + f = std::make_unique>(command); + } else { - f = new fin::ConvFin(); + f = std::make_unique>(); } for(auto& step_it : command["steps"]) @@ -159,8 +169,8 @@ int main(int argc, char* argv[], char* envp[]) f->output["input"] = command; final_output.push_back(f->output); } - o << std::setw(4) << final_output << std::endl; - o.flush(); - o.close(); + output_file << std::setw(4) << final_output << std::endl; + output_file.flush(); + output_file.close(); return 0; } diff --git a/src/tests/fin_input_find_compile2.json b/src/tests/fin_input_find_compile2.json new file mode 100644 index 0000000000..48946cd8db --- /dev/null +++ b/src/tests/fin_input_find_compile2.json @@ -0,0 +1,3 @@ +[ + { "steps": [ "miopen_find_compile"], "dynamic_only" : true, "tag" : "resnet50", "label" : "resnet_tuning", "direction" : 4, "arch" : "gfx908:sram-ecc+:xnack-", "num_cu" : 120, "config" : { "in_w" : 28, "sources" : [ "issue_1760" ], "pad_d" : 0, "out_channels" : 128, "dilation_d" : 1, "pad_w" : 1, "conv_stride_h" : 1, "conv_stride_d" : 1, "fusion_mode" : -1, "pad_mode" : "default", "in_h" : 28, "tags" : [ "resnet50" ], "in_d" : 1, "cmd" : "conv", "activMode" : -1, "fil_h" : 3, "group_count" : 1, "dilation_h" : 1, "in_channels" : 128, "pad_h" : 1, "batchsize" : 32, "conv_stride_w" : 1, "conv_mode" : "conv", "recur" : 0, "fil_w" : 3, "spatial_dim" : 2, "fil_d" : 1, "trans_output_pad_d" : 0, "dilation_w" : 1 , "in_layout" : "NHWC", "out_layout": "NHWC", "wei_layout" : "NHWC"} } +] diff --git a/src/tests/fin_input_perf_compile.json b/src/tests/fin_input_perf_compile.json new file mode 100644 index 0000000000..b6aa0012a9 --- /dev/null +++ b/src/tests/fin_input_perf_compile.json @@ -0,0 +1,3 @@ +[ + { "steps": [ "miopen_perf_compile"], "tag" : "resnet50", "label" : "resnet_tuning", "direction" : 1, "arch" : "gfx906", "num_cu" : 60, "config" : { "in_w" : 28, "sources" : [ "issue_1760" ], "pad_d" : 0, "out_channels" : 128, "dilation_d" : 1, "pad_w" : 1, "conv_stride_h" : 1, "conv_stride_d" : 1, "fusion_mode" : -1, "pad_mode" : "default", "in_h" : 28, "tags" : [ "resnet50" ], "in_d" : 1, "cmd" : "convbfp16", "activMode" : -1, "fil_h" : 3, "group_count" : 1, "dilation_h" : 1, "in_channels" : 128, "pad_h" : 1, "batchsize" : 32, "conv_stride_w" : 1, "conv_mode" : "conv", "recur" : 0, "fil_w" : 3, "spatial_dim" : 2, "fil_d" : 1, "trans_output_pad_d" : 0, "dilation_w" : 1 } } +] diff --git a/src/tests/fin_input_perf_eval.json b/src/tests/fin_input_perf_eval.json new file mode 100644 index 0000000000..0db9459b29 --- /dev/null +++ b/src/tests/fin_input_perf_eval.json @@ -0,0 +1,291 @@ +[ + { + "arch": "gfx906", + "config": { + "activMode": -1, + "batchsize": 32, + "cmd": "convbfp16", + "conv_mode": "conv", + "conv_stride_d": 1, + "conv_stride_h": 1, + "conv_stride_w": 1, + "dilation_d": 1, + "dilation_h": 1, + "dilation_w": 1, + "fil_d": 1, + "fil_h": 3, + "fil_w": 3, + "fusion_mode": -1, + "group_count": 1, + "in_channels": 128, + "in_d": 1, + "in_h": 28, + "in_w": 28, + "out_channels": 128, + "pad_d": 0, + "pad_h": 1, + "pad_mode": "default", + "pad_w": 1, + "recur": 0, + "sources": [ + "issue_1760" + ], + "spatial_dim": 2, + "tags": [ + "resnet50" + ], + "trans_output_pad_d": 0 + }, + "config_tuna_id": null, + "direction": 1, + "label": "resnet_tuning", + "num_cu": 60, + "steps": [ + "alloc_buf", + "miopen_perf_eval" + ], + "tag": "resnet50", + "is_winograd_only": false, + "miopen_perf_compile_result": [ + { + "algorithm": "miopenConvolutionFwdAlgoImplicitGEMM", + "kernel_objects": [ + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=64 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=16 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=3136 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=16 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f8ffbb181ddb59614f385a4d73403e5c", + "uncompressed_size": 25240 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=64 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=16 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "cad4bf973c5625393b6eecd6b9893f88", + "uncompressed_size": 54040 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=64 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "048a2918c11084f40ebe8154a909fc8e", + "uncompressed_size": 54040 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "63693f0680b6c679f3798e138c73df8d", + "uncompressed_size": 32696 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "42edc5ca00b9b7b566c8110a6dcd877c", + "uncompressed_size": 32696 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1a23762a062753e306a43356eb45ac44", + "uncompressed_size": 78584 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "8255b123d7583268f839686341fbd344", + "uncompressed_size": 78584 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "3aa2fd61cc42da86769068cbab0f9062", + "uncompressed_size": 78584 + }, + { + "blob": "QlpoOTFBWSZTWW1Jj1oAWbT/////////////////////////////////////////////4Hgu7ne916AH0XbS+mKetu5rue5N9988fbp1PuI1M7HOve6E9brWC02V4fT7gBps1Mxlt97w86PQJdmFVAG9993vvt9vc+OvuwH33va87twrnPJ3jZ67lr3vS13vfdyeAPkegA+42WduLqfU75e13uvN8xnvbrtu1vjWyVut3rb33h67zM+srvPPevbu3l3ccuRkaHXmsOzveez2Oj1DYWYGmn27ntx9ePV2Ovew1R7PJwl297bZrU893e7dDqOze8HVeF05DtqyFmwA92dOsUad2FKDVWweidNRpVV7oM3gbYEwvasG8AAAPe73B9ce918HhvPSPje9oa0HeO8sAY57Ki725KAAAXdejPHoDgAHWKSgLk+j3usIaJBAAIABMAJgTAAADRpoA0mAmCZMmamhkyaNAaBMAhiaYEwEQaYE002ptU8FPI0xTTTGTSm2mTTKbVNtNMjRQNEIIAAAGgAAAIyNNBGhMmATAqeDCap+miYIwRqn6ehJ6ZNNDU8TQyk80G0mTRqYnpTaTajJ6RpsTTSZqepmmkep6mGSaZoZEBogAJogEYiYTBJmkw0JlPGQGk9JkNGTTQ0myp6ntBKf6T01Typ70TVH6p6mxTJ6h6niT1PKb0SfqJ6T1PU9Qb1QAekaaPU09Qekeo0NANBoaBoep6nqaCQkSaEACNIxGBMJoyjMjCNTak8gbInpTxNMqfqm9GjVPMaqeBGp+lN6TU/UynpqYR6mjank1Mm0aepijYUHqGgDNTyRpoAADI0AANqNAbSkQk2qY01PU2SeiaaMyJ6htTJ4mppk09NTR6QNNqGQeoDJtQ0GjQBoaaaMgaAHqeh6mpo9NTQ0GmR6Qek00ZGgaNMJoNADagNAAAkUQIAINBMARgAmgNNDQGgBMJpoBoT0En6TJimMEymZMkeU1PAT0TTJoaT0npomjQAYmmgAME8oBppp5T1M0QB6nqE0AEPSNVYE1yWZj/81rfcWXKg/iisDzNXtIDt/7zf9Kqk4fR9R38OZzPyfPvv7/o87Ydl9BiONyj1LGuNurvjkShcu//lUo6q7vV8O0MDJkyDdLLy/CQHft+N76d6pa6qplHgmHyUYnwXoDOXsTCvUqDwcUKgKemGAlGnCAIIZQwQJaF6y2fWTgg6E6+wjZcxPXhg8kVB7tB40GZnvDPDwC4I4VL13rJj+ql4UijBodBA5E2UJ9BB0CCKDEJyhZne5H2pmDskEPZMiFNeU8o1yFxAiG2bIJorrFigzFQBrrTLzd5v1SaYG0aBUHS1s5SuQJBd4Sf+jmmKO6YG9RLmrHc4rnNIFD3fzqEjlsQi7SLtB/2YbXlWo0wTabRJAiPY+0/EFSy6GDVlkpWABmBXP0piwmO5kxsPEOJ+nK9J++7h+IJxfcZ0gyNHdbyCQbDS1mCNid9QhWts32LiNfXiyNDW3XMIgAEmAJGV4yG05b0PS7PEpNa1snMgXyhK4pNDG4O6lopWLvnyQ+DWCztBpsE8qwtoaNDu8ztkLaWOjPZYswS0S8X6wJCWeWLQMWmyNLFpJ5IC3rNOoA2WYaPLiNWqpSEynOzZKeOXQlO2XLmk12Wy4ZPlQmbNNAzZYSQbb3Q97xZyWtTZmXNVa5py1FVaZzQtCYYXHo0EHTwOhqkjEZdOYYS7bVudfi2u7tWeGSBe1W7ms9cDJa2Sr461DZhhdybiZq2cLe7tbJasJJJMMztbeyqwyVa1pG6bNqtXoWy698haObFTI47SSpT1J9vV79dew9GEbd71Kqpoy1YunKqhuOfIowq1TXrB3tVZKlgkhlta0kH+LjKbjjkk/1E/T2PB0OtxurvuL+QJHotCWiBpflT8HTvtQh9bICY6snpQjf7pmD8+pm43OoVVX1VlaGYotDi0NpDTabfChEqjbqSkuRSVFpTRTGm2A7DZAUaE2JKNJqmIpqgKiqlYKqgvRE7jbplKlAICaYMCNNoFZpJKDQkiIhtjHvarK+bJiU63wa52MKfCh3uJT5nSpHd0q2nZawvs60BuzOQ1ulP/guGNCyOBrtxukIpREGZEAaEbAGdAKfJCJp/PpCC4gTtwpGN7+mcDgzd1qw3bWBnhFiGD1XTfNtWGj2ORKI+pgQSCqDLYgcGMaTA7V6ECmGZmYoHIkwb/kSabVhpHwHtXRCzG2Rx9s15Ts/auJC2cIty0RiNMBb2JXGmDb02KVonZBiBwgUzb0iJxvhZdGDd1qMO+zavX5nB8bhdK+m42bpsaGnpCw3m9mZ+n30TS0tDPz1JkZGRv9TDuKHgcF3rsbhcOp4jm50thSeBxakAG+xRd0b+CXC5a4fYkEs3ff64iqJFHBsQ2ZQOE5GHAnElAi19Vqev04ikYStCNhqcAGlo84gIw9eH7FWA/YuYoQKG39Sam3gll2bgisQBgABz2Lu89igS2Bgl0uviMU7rbnesF4Tv0NzRsPF7FdWg0Wj3fr9esRBnCDYuxdFRsyNLu2YXRdUm0jyWjhsLqS8Ue5nCTH7mWqy3i3eNYlKatVCIHDZICiQGk1maO6yEukXII506FkEtozGjDJAwQroglznQIqN826ssLHhMWHNcuiTNzKzlodzmDILAAsQMhuFEWQ4KM3mMp5MCyCiCBJBwakr2VtPc0DRiOZiZXgrGAu/at7TTW9wVgxe9S6o0lw2kVqxLFYEfj14BSZ8iCgU348T5Wdp7q66H9aE62+ZUKuH+9H7vwaCkiTM+WoeN7C9aTSJPH6be0r8n4WJMhUQ7SUkcjG/9BSRd/HSGKM/dgmEuogRtImsPrKEjNQHKXjd2Wze2vS7m0CueuSbIDEjGitKbTK0Cmd6/5d119omX4E9Oy/MaxsGD+XZff1B2evS7zYisdH/PS7FrSv/EpYfj4UjS6EW8xibWvPFbpHSyW1Rk/EuebYh67tdHw+izoKYtC/Q9BPiP7S1qUpSmLWta1KYtjHNe572Oc1S1KvjhjjkzafOmiMbpqCcdOnqOzpsccTGuBba9ICWUcABzRINOAyXh3nL5vSyO4tbb71HO8C/lh1+zLjcOPee3QAvvFnAxp3W8qm39VE1i8vi1rQD6jACZc8yA5aSJH7Eo//6pz/1Jev6vW9Pa49Ll/p6Qc2FlXsrv29n3WzZs2n28k4n3xpPuHE++OHDhx973/3fvo6OQo5mimpqhmcuDTwaWlkx5NLFgv370mTJk6xMnoNAPXAJA10qMJMINBO0JMG1XcO5Vmm1Xj5DrhkKsXZw2Rnq7GNEZZr7bwieAnk6/4GSxb4PgVqXn7R0NN6Noo4zRxbgWtDmU8mbNlzZtPJgwX7LVixXvP4t9We41elW4719cgwoeKDBvSbOrnxy9PT1sbWPHjyZdFTRTeTZ2jRopZZE62suw5uXK2i7raNDy+NcTI12TSnXqbylS292zEohyGoUkJCQ1cjOTsDBQdfX1tc5r6QCJpUFTGXNHsVg3HIHp5PEMcTxdfJj0PPRTfjdXM1Gx2k9IsZuLT5jW5SQyQ1BqSpi1jUGQcPbgROcMIMIslhH2zIGdvIL6KbjvvzUTj81aA13p/Pu1NOpzu186v005uLSx8eP0sa5jfRvEWVcbgoJjg1BGNeY0ksyS+kGPg2MWRYlCG0Nov3Yk+iINxkY0RY2NbxrxGI0No+/TxMaW9DEE5+A+KczOUoozuJHhkshBTpE5dYLmJn8s6VO/6TP5v2GZdGK6e+VADehEeT57mLIaaouJi0z++oUq6j9/5gbGYMVXZgz/xUtg/N/n/k7YUqfPnfut2U0KshOL2ZNkTVY5joytUw8mIcvaE8Monv67mQ5bJbmUo++Sbbb7S7exJJJsYzVqt7wqqjkcjV4uHF7PyFxtjjMnnVQNnoNoBsG0hsDqee4R0Pr60ZTp/Sk9K/pbyvT6tOyIAAezUPy1dx0UMWtmFLHoVF7W8JLrzVvrAP6UD/JSlCEGZm70zx3PaK3qB/NbbBgcbA7+3ISy8aWQWFLD2fW1/rejKAew8cYkla+PlJQBJXT6kT2/MkQNL5UCklcojkO/MuKoxzWKrPQgIdMMUFfL82AR+rxMxbITTBVM6aYJ9DEAUzq3hLfkMK/PQX+2WZbmE05hR/oYpjIsEzxkTgYjkK6M7FC3iosAg3yFqGQF0ijC+Ll8SmgBL4kD1Oun9Qcb1tXxa9XxhYzWfefQ9b6Hj59nY87zus1tnZ8za+fyRv9LIR5KGC/eu3LbNiv5VevWq+tUp0qND0J857t+z5+68/2Ffy+F4/C8fl+Puozu7ztb7tKPLvxO1ret4vY6PZ6UDhGyvjNmYwBdowDSMJlrlElJDfJ63lcbr9dSUGlhjYc5rGocxrVjrq8lK3BUIQ5IgECKWte973Oazaa17YQb7zWta17nNYxjGMYxjGL7P01PF0IwpvBVpV4ryr7gaKxfVYdXymNOXBQIRJzFRMuLk1lbCGNYoZj4sXNTcVuEuXmxsFU2MJAwtgMR1iM2djiO8SNxLPEtMS1tMS1hRiReJb2+HcDDucN5hy+HrcO7w7zDpsPysTExMTysXDnsL8dDR1lfTJO3dGpR0c/P2tpPz9CignkIWpvPuUkw+wGN3ONn2P56+v/2g/eb3tPBwar9e19pBwsJYaKHTp09lMG2weTGx0c+d/9aYCaHEtSB1u84vXMX/tdPpOosXPn+3CQtrrcTFxHOS1GPBwdDjS+zr4pLHKu4mVk9bUTcWrIJTV0vXM9ZtdKqarL1reymeyvq6+aUet1t9dw8vJRs5HzvuTudQbbz+mLvtC9C71X2++WfPdjRI3+ks3t73dkkopRCbBsLwZF4mw3oggxeF8b0QZ0KBAgCdtjlT586bpT+0c+JlJCcolSpR7mGUMoZNihiGIQuC2VoUFYMVioUHgU/Nr73e2LYt6Z3GXNLSF4XhpDSwGMF/AMAui4LQsFgrFKUFBUKA6UoKZep4HgczW1r2ffzsAwDAMAvlwvS8V4rwZeGMYxZLBXK5XK5gKwrBgGAWhlotFkZnnd8992Xgd7B8DnQ28PimIg7+IOfFHLixJkWjM4rTTvlzRNE0XQwGBmGYZiylmBjMMwzDRPmzBog+Do30GXLkRUy+uUVJ3FsIOP3klK8yRM4jao1xOXX9pyTE5AFYGbtEMkLUDopITgLVzlgKCDMyCgDKHNhZoLhRyJbvIlz97Gmn2wqla3Ibt0wKQxKZ91ssDChYJai1QLiBTKnkqhXYKVaVriZffTBKkzQWwyfR2PvbGUy5961s2eg0MIM8+nQaZV7cKxoGM8JjlO5Tj4SA8CBc1fEd4a0xVELWlY56F/G85Hbc5kHSbW/RYWKLJbchihpav+1tlQH2iRB4iLxhAxFfyEDf5yhLQ6LAQFYoRNosE6XS6XTsYDaG/CI2n3vmeX5nqTBtPkEbT9/2fG8i70GvQ1vQ33n8shdrFao8PR6eEFbgNdxinAi00201TAgBgm7AsBSlKUpSk7gwQUpS+wBlgO+H8JHqmPYWBEAaTRpM3OpDOzs7yqnE7OJ5VJIlabXme9xCIDVx2wYQXpbXpeZMEwHI0tLV3dy5V8+wrNUOjBXLlybV1dWkGYFSZXZFNsJ5JFEkTbCeIRCIZfKozZgwQmAYMIm707Var3umqQUwhprFTcgR7x2nX3Pgmb0ORSCSqch3zp5mDU53M527q1BzNDwtTk7PN5vaTaLow2r94DMHtcxznOdmgYwIAXgdwNFwWCwWCQaWrq8sY+gF5QbxUkKs5FKI4p0FB6QeFFnal0DQyYUKEBCOEQbwgO8QJjuIIUQ4cmT1sSJ05cvPduyAJL589swXz6UI2RkMUIx3WPG/GcBmxyr1rFarRxTHFGorUMaCwYzJiwgsrwfdEhbLpp3SJ6LpEEWC/GMyCpatR6LuXTun0nlXZbRqo1EagrNG7bkIZwi6gQLL0PeXzsTUm0m3izqSKjFQzXW6eCDwQpLz7M5gveO+wmqRZtttt1QqgkXnvJ9KNDQ0VNE7LMIMGKiFcDh4nUlHY14hxAwZCndMGxt2ggnau+vYsZd3dzXjWDvoAq1YGwbBsNYM+eGzs+DQbOzlo9Z61ttvOBSDVCxGm2yo22Nhdg2Zs0KYsuWqNnwoFMGzaGRk3ygbWie+o4W+7PLgFuPgQjTY2tkFSu02aurKaNXVxtYIxrsm2Ltk4ZSzE2m3r6+Ra+vr6+vczAjMCMyKYNg2nzQKAoA5oQIWaG0NgOrViRaG0Nqk0Uo73zPN87v+h4PD3FQpsbHwIDyD6Hk7DN9o11ur7tni2rUr9+0UL6EWxbQdsIdfRsdDxecq4LiLh9a3deFhWgtBaCg7vibQdyzbUBQFAUc1l9KSkpISBZB9yDJt3K2QJyE51IXSbRQBkcLquZlgOz2WNjY3qdtlBNaeBcLRrQQMHwmxuBASu8GHTMAMHkGgBctDWWLZkFgXDIzLSt8O5CDBa4KPwqrXVZG/E/BkgbvrtVXXXWlPwlK2vNb3uJophC5A4HaRnC+aMHioSRmVhgf3ZEIXXU2fF+HczcK8yQcG38a0SCytv9b7kPdW0fkgLAcYuig2wSIi2NFsATUOzVOXeRBDzTmxyFnLX5efy4VzHvsBIyGqZSUlAStLSQIkNrKyerx8fdZG73Wm5nJub3dfaY9Nl5FjY2O7d5W32OyxMakAa7x5kX1pc7iG0XHpVuympui1f4rp8Uo5e3oKUAz+6ZEdU6dGBWhIhWq1yZJmZvlu0XODXhKLPuqIrD55rHcJYwecv8YyK51Le3GrQ5EU5RcrOAuk5h3wGMDZ4uLecDg4UMGpy9rCwwgYKIMEqsVjVFiXdUH6o9rLhf7ndqGhz/o67ZSe3o8LgLkwXLspE2xKkIxRME4iKIhGyNIlrNxM/qhKDfZ5npVpmlwi24U1XDbPXEzQYNzupjgW1iwtt9dxDbey3Aq9hmRutydfGO7Rfc6kZutxynNXV1VzNNIqpLZAwZEYIGRmDEHqTH6fgVGexuY8eNtEM0dnhyFkFXIS9NxvHfIgnkbZiBAfXgX28pA8hQhvXohwzO9cvXiQxouyrBAF4Xs7zgV1wrrM66qCs0MrMxXWO11+G+hL0MKRZClYmiuFdZtRY1LDsGvQ5oRi1qNxvpXJFddZuR7nABvetT0WrWbbAt20WJTiNPZtTORwpUZi2u3YdKAanFyEkLQpOlJGLkr140ooxajpIhLIF4gkgE5xFlVCoSwxqpUdEJRROBFVVogeRvvaIV1mccN7CgwnDORzITn/1+KQUQV2SHyr9dZnNO2rrMxZZkWWshFLffEEdohhLCxtq0Zxtfg1YrcHwFdVbAWWlZEE1VCcKRNFDqqZU2IlzLhkEeb2jIUoIVVUkaGJWmqtUfbP2xnvkIOjGCEIi1EktslZA/2ofINhKSEIvvnNsytDhdIHfjGSEIhB4sGK1jM0Ng7IU0e3KTkIXCBmiEoJgHveZ2OZCBmiExCWHS1F2l9HDtczQ3fv/M6/43o4up+f+H+f+b6XQ6Obv97gafK2vM5vPxORaSnW73qenuu/o+ptvW9Tvfk9T1u/3/W9X1eR62N5NXV1dVVoNDvYHLLrfSe4ON6Hve/5oN3oPcDch7mjke73gAtzTNxudvXEAhA90yLnve4zePDg94IwTWNNqGr90h4/BAaGOsemPwW/pYTHBSr0gTZwGwbt+Kz1AUAAEgwNUF0RDftNLbjatb3h7WzcrK11bO7GboJygn56fn7CxpKiho6apdVVTUVFVVWLuylKiftbi2nLe4uLa1tbi3uLi4c1VWDq6yxrazegj6QJRRLpAqMiTTdqbIiPpESiiieaRcFGG+WWTZDLh3CxmND1fn5vThCEKD6OSB9Hx6D6p5fejkRj1paJj6lz1i+p7sYxfWPTGiY4oYKSJQJ6ZsMwvJWjVai9XLa49AtEyhVVVn5G38Z+WKK/ccZyqqfF3CVHfpaQG9xSF2TQy572vCxjW+Y4ee32JT75nr4Q21y+C+utdIe5ANa1vNUJICFrer8slhSU/hkq43ZWt2SSG/53OQSeIcVzvm3VBTjHq+FnXDOePPeracAEPkrLLfNkpTpb1PsDufHX76U6bx4iWK6pbzV8dVxrcZVZT0py2RWRSuE7pr+SBZLiwqiQiUYGExG3Fry5WDOuANva2lm+5Hcw99X0u7ypVazyP8f9ez5bNzt2q63jLezxmX2rN3l53Y/ws3+lpLv79yLe/r4EVWRb19Z+aLCATUIJlFbzS/n4P1bjfacB/Rj70mhmZj0OG4BiiHEBneTUbA93KnuVw/j1JiK73MYZTgNWrgNlXAbt3AcOE0cnlMQxpGIY+YuDHZMBLvsIWn5rpSEUhkA140dvmrVs7zZ2ZyySdjJ/MLmEvbkv/WS+aTOaTW/uSc7ZJ79koQ2ShD+cUIc4oQ5xQh3xQg97nNaxak/78t9oZS6uqWJjzRwVQoVnoba+zcnB6vIYcOOnm0tIT00+yT9dYWdwczK2+B1+Db8nvOtjTx3NvcYb+XSw5dPJm6nR7vhV/0UpMHjx4xaQ2xMVbjZdWC+SxDG5NzyO04GIPrUktylANffkUlfsl2aygEpalKZ29+pSyHg+rAe9KHBAR3S5nD/VFfX6P38C/vt1jce6X6bLF9uIpKLjWjEi0EGCUbAbEk4JwRW7qXEviSjSNlYfPXKurl8tXV1c2sSrh7eycLNstAALgGVUZDb0KH7RHjfPvd/+n9vKIcTmfjHqeDqfg9j9flckCTaEE/l9oP5EW12GZFu6JzrHeI5qJMOndhiUeRUZ01lMad48rXmxicG/yrbApXF01uoHYWkTk3rRN/YYedt9vm/u0u5sM/cbj9n2/9+z/r+FN535u4P+7bo1aQ8W5Dt1Y5v6LKyagfo6gFoQ9IwFoH5CH7vMId8ho3SnttP4P93dox76DL4FMFfC4izZuv9qZHIdWOQjAhGAgkP310RgUYhI9XwvqezAffeQIX3oFaH+JaN/KvdniFQeIIUZP8UoD+l8iWQ/GZDuWgGmgTloE0QmRO57oTX7qnjY3+8+fbu3H7sYxytCl52hiVsC4iazEJBNopX4Sov3hYAm8chHiOIlu3q6tDU1JVI5c6Wn2/4FLfY/P/totEIIEwEZgWDmASyEw1kywUohKm/f/B/AB+Bf/I534fy29qPLkqW/KxGiw3MYhEIRiEUCPBIQSH8ZD94h0Wshzsu3DV+KOnFsM4L8YRgcY1QY1X8TEghIAkEDMgk8JRIabEJ0wUCEtNGER6FoX/Bu/a5y+Opm3uZGRUkW7I0aTHjglwUQE2KI74C3kVP8IHWxYsRX+NdpEuJwWWN1I3+/UrrJe3vVK3sRbCZiThmkmyDSm4pB2oOEhhIYSFshkfWXt37FCZGanzJ6vt0s0Ggwu9uz0poTp6UTp84IM2hONM00pt/anpXD/Un0CBkK1EhRIdPuw1B4LiHGBxpsmao1TNDS6nHEbpTMas7anU1edAfzljPgK0mqBrqmoUrTnrJO177bqxOJ+R5CmQ1zxhCUpHXTUjktDSfzUk7EzI0klxLigdZuJhoI9gGR6wMjk6+rL+599pp71ZcaWqbNlLm1TSxuJvk5bhLbC3lIKgUtBKGMDFicaCPEZHiMjxYMFudud+/X1rbk3i00vSFLggXRK6gpkM1IdpXyvXlIJF65xFqJV/noCDwd8y9w+EYiYHO1Gk6EtGNremgGLExH9f3P4LP4I0Nu2hcuZKibqz9z8O+cn/83jJlPsrCGYqwODBIXunRgGQdOiDoh8kLrtd8V2n8b/UtTIIVatZVCGxCwhZYQsIZYH0N11ocmdoh1kf/PwMuFZCshQhQh1uW8fezM93nZMSCSESESs2tba5OTfs42PweNl7haK8gBfmVbzdWYex97befUKSRQPOvlLIU7Xep7BZ92LxKma+PEMj6rcXF2JLWFququc2cSA/GGV92VQkzJaJQZw0JU1hdMrs5ylNTpyUsNTZhzmkzDmtJkzUIDU2bPVNka82JMkTE4z40eYupMeWlMmXLSleXLknLlpkHLlpjS0IEuXL+9/VTpAafJpAR41ixKlVLnAv/yX3oSQ4zsE7xvHjxyaW+GRExEHryu/5j0hzudzubrZutra2tvfGyOzl7H+nNrvFbA53LQQhCEIQhlXH7PJpKUpSwTmHUV274x8Ti1KNOm6cuHHbQnEOfViOHT+rJKrVseZWigt6+43Fsb+bixMss798AXDhowgvBk9LcR9DqdfgzzZ3qr2EbbFi53hWupbtWrVqlU5z0dbDXXYo2KcaZGjTpXbrqWOSIDly4SK7Mu7ZbNmz1vaXhuJzrg+dBSl73WxuqVhrf+LWtbga1rWtbf4WSWf63S5fps4Wt1fDxYsWKWfkOc5zncODNrS6m5xz7NEUfSlKBjTa1blfrb+96UB1f10a8/NVFa+fVs7ENWO6vK8/rrYbKm1VVMWpSkedi57YX0RijYslkZFmRoZPqYbfI33JvU5XNswryd61b8m5j3V+/fv379+/2s+uuNUpSpOc55Ix1Zu5ClKVt3jYzmd+e3hm3MXd8b4O67u/tbi5n6lOrSlM+z4WGP1ZonO76Gpw3qsv11+rcn8+j0qpTbSuy8O8+EHW9PY9Dd+v2exyttk+NVKUpVWu347Wtbyxk3PT9WXqfD/X9LTS973xnNG7t5ljGc7Xy5znOmtan1udxetwetd+/du3b+S6c5zmuc7dcNPMy8DbbcV1znNa1jGMc1sPQw4+dtDVweivQzst0e17FV++5rYaGwmzWRmUpAce3pN5unZwrjGMZ6LpSlsXbcYxjkW9gMYxmSfzvS5LGm1n2G4bVre3OK4eSeBrmqbm8x8XBwMFg6qa3GUgRQUNqo+ysG2kMRQgBwvF/Lyep3t76ng+F4Vhn7Cz0M5a2+ui0Xi+PoMpT9VX9l23oebbWXnW2e8+21em1etyNerteGkFlqc64gFabnz/UeN+n+Pm7X93M/jQj7/N8Yq8uj+PZb3w7JL892JMJqUkg+KNC63rEh7QVYAa5MH0Gv6LTYL9TV39b9bfbP6/5tzZ83v+R7Pte5+b1vcV8/zf7fPrPzQcH6lX/P0EVsVW1q327P1a+v9Ppe5HQ0/QycShUMjOTPOP7cB+p93J+9mYp9LTtQ6X+OUv+056E9AT+5GP+CMfvVylpy0x9rvpStSlacOH9YOWzCyuTA7D7VXZMiIF9E5ZkC+9+7AfvpEiP/3ixYv9EWLFivo+FGJc+wRw7A0tYqzE1LkVLQbP44Y1pEtgkuMaDJPGMUBgi5Fo+buPucm/yWNaw2tW1LbaTbaDG8kQdsRU58YPbF+F8dD3I0/PiWu0g5jTe3ilADo9DuIRudSQqcXn4fYfRrvqt6Sk21PT1M7gNhC/NLRNCS3GggIV9Qk02BVX3A/7/H+Py6z36+ol5aWfNbda3Y7HYu/nlLe4/jTYPzQxAh+6IQREBqgZVZAqsICjIi7PXl5PUUrqLCzNdaEBKOy0dtw9p44zAsMWGLDOMTbxOkT3xKEIQhCEHvc1i1TBDdmCJxkANUwBWZAq1es75HgKn52xEllu6ENptHJYkU2CqMD8BcjBwBSAFy1c6Ha/gmLXh+HAg3BsiIRXYkel8CkKkikm1KIC0wU76TFkWrSIiDyqvox0KUBH2vteTTwcvmTImRJPm5/LZa70H5SlzFf/lNQht90Tc7Ainvpzd1SkUaUIIV/YqJkpoSM7Oy/XkJWAqBlLIhkH5X2o940lXdJiF4Tws/s8yTKUZEU2xkRd+DAD834Bghr1ti2958FKUxsHe97Q7KPPoOHDhwmKoriryGripcVKipq07+MYsc1toh0TIXzIF1G+Rx8V7Atfq2viDKCGvpwj5fnV0kFjFUMVmc0fwtI4XW2ODJiaMEIKjBfEyNnijIkNZwl8T0VpxAOlqQBFRl4neJirjDftErPY9g9P2YjIkIuG882rOUNVRlXbBGKObddHEurazJzQYiq0qf/P2Yo8fy+X0e3731QnvezWrKS4XO1H4OtpX+Hi6GBQIPfuyxFatXiHjYVBFAfb9943pyHkPshWgFxixaxYUVVTJfPSh1mqGSQgdVrrMk6MN9z9fsWaea19Lc095uIVTlzwVf1PRijFQNa2TBKZinag1gYCnxpBGCxbZm6bTRSaMrWWQDuWFmU8xmiWVhwWF8Id1zVKYWZ3rxBb40zF0apgJMQjsRdJiNFASwx8+ETRIMDUXMDRCWDt25rodzuqelrRtZ8/ezeFzEmpZjtSipCjILz0ABB878fQSFzILOjvq93ve40hNuXufOSsgeYgbvZ1RfZv6QHnGHrMYDCDHm2KVNZEgwtAnTun6eAkc1YA2WEUQkQPKxMCgoJeMhnr2ye18TZWOFaQN3VP0jE2SRkdxAGaYxcnkdPsa+6/YbGEAXjmXjK8bpVVZKPHgZRgCxnDuSS1lTo9CKpMChh13g5ISxOs/FYEXpHSu4yUyAGEw+2D6rxc1dfZkKBpHl1e1s8evMYLA7zvLzi8HGmoarq1BVmiDe9gJZQjMsloUCHH3v5I9fPq5rVSTzr97NpQJMibE8yvImzrWCxN7bkS13Y5cbXXVNN3d1hY+zxcjd5G03eloYGDmaf0aVrqfU9paXRpYVMFlGQmTIRuXiRNs+gD7DA4dSBk9/3nXJLUN1FFhh+Gws2bMUXTCYMbVy45zlpWpa2AaPnvSNdPHQhCIpjFcYxeLfSCAdiPCMdgxsHWZUnFKUpSLhwMh2ztWrEBCDOpQETAtWdvjXlgbaOx8bf+qzsSEhIXr17rZZeLAX+HdS2lECpIqUKujFwJ3qcTuoKKlFCLChF465jrVIhJ8XQ6SezkNSvaxleQycx84wPKMAJ7zkxUjV91qIrVG6sFrNbnHnig8HowR2LFrxJZe0wNjEhNMzJTqK1VqFDtST24CEHpAG7tr8ZjFrUxunBCQTGMT5ZgvUjoLmE9bpIjMhJ4nQSVImKzCuYzpzdKmiPz+x6/D19itnjdrV7Wjt9r2Q2tra2g1Ptzh2nO6FEbjndpWwjDj0sePH0O1x48ebn6nacLf2t9zo1s7GbY5PJ5Gtu63Gx6xc2tsewbuKmoraykpMijqampn56diKOcmJeWlZuVuL/Gw7nI1+K8yMfX4mRkZFHVUc/b4dpZYyhC8sBK3K9MSi2qm10+qRKFJV6QTMhpmONxfa+hN7+G/JqLy3JG3P4P2vregGX9L7OX8Z5j/3+T9b+TqbdrbV72tW1a1pZmt1fb5aPj780nu7aLWEiFJN50bUe1WSfdMLZIL8Br7uoQrQMmtBaFsZhPk1NeS025BFRryTk6i9xduQx2YJlsAE3tqIIQPG2SHpQyIMbe7fIC8rDTWGsCRxPe34SvVnGfOYtInt+rHE4kmCZ7lbGbrzGdPolFz4HZ1tN+ST2NHu/utFuf7A1ARgeWrRun7HokDJHzZ1mpUycxayOiLKwfCR3oq/qeDD4ARCT5vfooF4Pi4gu9+NyPjwCC8PcBm4aJV5qe0G+4GBs3MLA96lwQk93Mj07z5WGGLxgnF6aKV54rDz7qrLCGbvQ3XvvZY5zjl4oazLb3D9d4rDDf4G7RsZiF40YpB6iKOJzklI6vS5TGn5j/Iq25UaxaZLVJSx0mRLqrlw7KoJWUjOBDwSZCx4PH6zeYTrje4vo/HJrB5PRZvCZU7CvJ9kzDbI4vFqd3Sc0fHVvyW97D9tmsTbq9pHNJaAB1Vckl+InlEq/lqzyX8irwCVZS3SJbJxVP5XfEwzdrsbRLwBx/e+IThdZjcktA4oeEeohaDN97mJuw48WsBayOCyijYLXRMEVdkev9EBgK1u+1pr9wRb8/3B5XyBeL7vvVDxPr5f1PhSzHhXPMGAYQsQYRZFEWJERiDzJ57pwZPH9EYSDBAsIwkQVHQloVv9xm5/PnNmW9wf6/ZS/4+rqfrnHCPBqWDW72NFlTODQwrVMft8e1f32O/vO/4830PQ+fB/wxW+Ytnfw+dQy81KfJTgTc+gzAoDNNA2tMno3utT6MiORTmqcb9c9cNzvaXNGrFEAFWzHw42YAITMq0goiHONaxt4ayMHzCiyOvuTPl9StoDTMNylbscYRIk5POGvuTWIc8wJ0TU7vWIQkKbR3M1Mt7tuVEzlosdPdDlXC7RumKZtQ2yS/e4Z332OfX2docwRvXjs7g3sUCiDdBeHEBxJhnHfIlxUIQYhfZ9N7FNkkUd6j7PXrSXcIJFfhrVd3U5ebe5WL2+2yaR7/y+3293JxcRJQWbQ51c9u7l5t9vxsmMx9xmZPgba3rMjR5W72PA+F77yfU9T1PK873HK8r1L5VjF/WQYAIx8XHevYsWjRixOtGjRo0tLS0aNGjNmzVKM6pSoVKdKpUqVKlPV1dGjRo0sWtqZdLW1dTNrZ8+fPn1tGjvs23tahyztq5IJKWCysoKaMcwrlVyxQdmSBOj6EhYb8Wn9BRa59XoUatruAQEVh+MfE0yqId/rtezUJPGTdNnJ7Avs7rUwDygffcs2NlvyEmqvn+oiNrfUKLBmPpgPa9LevvY+vb/RFJjYZjD+X8kWocLAasWib+oD8nCB7CPuByT+JG7Rk8V5aQWNaNf9uXX0Mrd9cCBIi+zz9GuP73/j5aXRs+shIs3yTPOSAWsYUgGoOk0nle/FxfFyHzN3gf7SHs96VFXZmRvy+eB/Y6/miMiy+/1PncTSOTWOo4/USNybR4CjZTbNeW++Uy7+0VSl9qUc5ebOwwsSKJgLRiYJKVK3TX4actcIsxfI81s9t+cOD+vT/b+/S4mEj/1pBno2kYKNuGEi4jdLOp0ugH8IZ30v5MzJAJdzNOYByrdu3Uu1WN6YMDorIOBZ7wWzAFfBQBXCEIwQzfkLxBO+YkWyGKHHIWjHfC6Q4b/1p0qnOGjm/Anghq6WwgWqmi31+sRGKotTI/zI5qNdFRFEkklSabKDIRUdXXFPc3AazlDLoxcm3t8qdGSzJYXuxAq4PfRESTZXyilK3Bl18Dv7/DkN03briC8x6HHmY1s5kFgL3W939ijNmpUTPwtroMzavke3sotAUi1pFGKa2WnJyQlk5hekpIKLWqSFkxHtYODaeDP8yL5mZyuVysrncCF1Xh52ZNc7nWE5zuLnc7ncfnbjS5G94/F4nAw5zicjkcfjOuRyNtyORyOdzfDt+dzudzuP4HD53OsrCrscazTdV3Er1MVOwu0mFr/ri7G5yN7vWbg9SuLFSSvWjQGUAMxiul5SdmtZX17x5W1tdO0lFQ0FJR0dc8ePHlhYOnTx48eWVlZ2NfW1Tqvrqx1YV7l48srKysrW2tnltb3Ny84+yuPd933fb6IwAPyl+UwaRfndi3J4MP3EBVctvfsQsNQKJprU13gKoV66xVBvO77xriUDYBL3cJYEsABje7gNEyEJmKpAC9MZGRqMU7TcBH7E9NeNgf3tht89oGJMLhA2/d9BRMe2YQY4q0AZBpkme4l0ODM3+DSvc2R5kIAxHaI7zs8Trwenw8+N5LEBijj8OXq3/ZPe31ULO3dATHfreEj5bOHu+T+3+Fw9c+BBNikYQEdpiSzImxjGWajSUYrWjcbYmwAMMfp8o69LmJJZGI40gGz+lstf6uWy6q70nq584SiwjIgRcZW+77Dv9jaSEgv51h05TwYVsI4IizCT7IxEBcnH77rpECspqlSBcKy40mmviptd81rYcn4+v1ZmbgIG38/Ef5yT8SAXwEQRCul4r4+hz/xVwvO3I/kY3VRjLJ3pJiR2r6Bkmkv8XuejEru6qtAxkxC2XmbxN5yaFKTUqvgKJPVMSgnGar+bHDSVJdKUdngpFbk83EDIhS+nksvTVIMzCydwXOHhrFjG0lq6sVVIUEA7p8SQJX/aXeJgQTbFwEwIpGEn6LbH1tMl4r/DPZ6ywaT7yKSiQsXLFBm92tFdyORwPA4XD7L2iiszqymx6eVYSE32pGcraSN0ut1qrrda+ue52+z4Vfqdnu93u+Bj5/d7vU7XY7vjdvtd3s9zud3ubnu9135mNudPaaHPxnOW8lw7ycdTj/HN6eLb/d0ufV1VVZVNlWVlZZWVlA2VfXv1lZWVhZO3dlZS8zMzM1Nzs7PW1BRUTqzr6+xs6907s7F3ZWdnY2dnZ2dpa21xcU+TwcWesuN3aG7tTrs/1XvBV4FiE6njt9FLASZZujY4VzUpNPSa+suJPhnvF3jrs8880zuENBcsAkkoYSLUMKFhmZGfKAxEIg4pEKG/r7N8e0vl6Ujm9ZZ4XnNeUA0DvIMeb5SaIe/SEOLsQsGgCE4fCS0jIH9/wt/39/+DedCK7u50tvHx89Nt5442aRwaHnpUvFRTn43E+Tjewp45/66COT9aOd0On1OSpybdH2cvjcr0KQp6zrKxjsJb5favR5fAzmJ+TUNaihfAb6v9RJNiA+cxkT8SLa2dgEYCEEAEkBCQQgLPZ6OumG9k0aPzQda4vjA7bX5ekB07C4t9Md8Ds7L69Z9u0a3kiQ5XCek0f7RrT4dBL8KjeL4yVpCLb1Q+uBF/TXUu0CImXKFlhXIh79mV3tnlHb6s5zvc0L2zA3Jq5iU5YIsklKIphktyI5ZMVxO7+z/k+p+d9f0P7+TRZpP3fR6NF2abIzSQ1qEjQwaOXx1RSGGDPobBDdSLD7z4Y/S9Jv+FqZtL19SB3vU62dSwriQhu3vNHs9rtdvh9rtdvn3fheH0aLoc3pU8lz+l0qrpdLpdLqdTq9br/J+V8vueB8z1M/V2hs6+xw76KdatWw48cJ/CgQoMK1q68a/fy4dTU09PTzzs2bVz1q1bX2Nm7du3tbU09GjPqZdGtn1dXPraM2jZ2Nn8fYdd2vM5XufXMvrf4fV5/xFIcfn/1/lCENGGiw9v/8xQhihHs54DMM2xtWrVqkhJqn99HnPu8fvlvAUMV9D0Xk9rx8Bp1D0U0sSxY5Njzg+lO5fQkk/YnAynh/cV7ReEvK6cDIbD611GNtsY2MaX3XT5XXeXo1oyTJjpBCD50Tg9rhE7a3hFGpDE5eL1VDU3lBHuURdY4hDbauFwbBmRhgwS3S2HViIs/SfuTSK+XAwsLlezlznsr/J4qN74tbC+cuwlvotGfo+NQZ7zxvcfD6P/LhfFW+otnmlT8zq9Xq0IeApWEriBgyrIK2tHbPCx98wHBsGAtmSAAGFEx9E1F7tTk9bG8qKIY/Z6mlg364C5kDMiM3aPXu/u0/EYpGRMGDM9W6n52wgi9AwS5mmNU8HOsVamj5mRGM7Osj6fle54/7N42KYOuaJTm6USmu95XBWrFixcu8r8fJ4HJqWnNE1AMhHnF0/vo7O4Un+17jKc2vq+H1eX9XmfV+Tm+l9fvvF8XSwdm+YcskUW5a7LtpBuLxwkjcCUOFQeCZDl+egEofMdActbkqgx6aUurIRduFusUIiFtJ5F9Nv233+mI71hvGTVW2IbGDQNibEia17qwMI1GowiYRpItS1B7v123g8pd4syfgfPRno2uw94D+HD636EZ/xoQGGutoC1qUpDTJKTMjXmGw13DYbapqAyI4SMFihAs10X65WPTRucMm8xCKojHFRHqlqc5YSWahHEsqiQQayWsJIVxIvzpE5Z4xWBAFHU/MQ0FMwXdykgBQvFIxmBcmsEl9cDr//s334FVqAyJ8Bbvnh7af5oIQEGZD+UyJiRLAR8iWk4WF3CjWbMuKsFkKUlU8vh/z0JZf9vrP/R/YhGfp9WMlvFLmYQEsJpjbMVpDYBPPgn5+OTE4f2febM9P3f6mJIIMhjRfsQ1uKvv+rYsXSKwWE/xiAL5fGgEn9OeuHOms9UB2HYN0uzoaaAIV9u0oEoAB0t3f2Vm7xBCt7rj3SZBft9ngvVAU4QmgJsBvOAo0hOEJ1+fH3XWOdnSj+smalDTCkst+ly3C9vdC5chKio0Q8Dv/N86URMj7LNvtGnnaM+IEgccC1rV61F1rV+qjMOXf91/tDK3Pwx1RvKjTW7pboMV8Isbv5EQ3JkAABdwmt4asH2eBGGURENtmq05BIE2LaATsanBe4ekp+HnZ7XkQnCpVknmQDpCS97wZpWrCzfZyXAxeCmj72uCAO1tysuSPmuDopXkltDKtOM+w5XcAh+InNjQp/5Q2aJBv3etHp9rcpup5tdL0uRc0GeJMHq2nfy1Q7/W3N7DbvPElG4tGk0A+9QgGY/cUzFUkyyyPHSBt07KXAacJCdzq+78KIFuV49tx5mdEnNhNtq2oiQ98ix4ivk8nOmpyG7Ju5X1p1RtbTBsM5vczwU8pRkzIQU7V+1VswVlqdqUgWIrhsSNlrQa4LV01baeTBPNgX5lAyjZl2JULKJiWZZe2JaxnXMS1jNKylYlTMxzKhmCZvjLxhIHMswbMSysZWM4JmIZiGZVmIZtGRbyfgsoq2UAxVQDMGOJfA1m57TfX7/9jbvVtLNf/by9F9u4EDNm8X3CZRkCAdgs5DyoLtT0aumx8aNFcYnyHzlCeC6RIy4mRWyPhj08mTIzGxy9/ky9ppzA26GW9yM3J1NTPHz586c7sWn/G5cXcNpqItXcz9tZfQvs+DzY8jmad3488zUMjexmr1o0Da4sKAqp8mBUUYeFAlkGm32gqfW91GvZ8jfzTdv2/2lszfRnf60sI9xXSsNdNjGKwxZzLakAEHM9/5zu+9hZX4EsD9wAJbj9p8cDH9/8SGzLEJHbASaakIr3ztSI7MKorPY4AZIj4yWG9eSwtM/Q272DLpUQeM4jJzBhElR7MtTB/5d/ush1PL87POvqW7Wc4NiiJogZvEEOG0Q2llEJCI5gSWyCK6zhjYApYKMtkeE9432d8qMFcInTa68jgnm/uTfOei53XqEsv6E21N9il+7+ZXEdRnJrldhIygY8h5kkwAoiYZC5YakVSo1H+QpgSJxQQLldZwWmEF45dvID17AdvogaITjIiRs+oidjvISVM8Zs4UEsajUsEGA2hsTkYQpQy3xwmhu2ZejpaejmX93oaBLS3QutxzvF3/j+962nsbLBbpm6Z1zTkUbY5EDGCbAGwFFi83k+19b1VhNcBuZFupkWXnCrjXB43I7Kj33vbd3yPet3CWYQEs4Yo2C3DaN6De2RRDG/N/jY1bFigvhRKyyWF95bd62vwvHlKjCgXiwRUz4aXge/zpAoFki3IbcNCREv5PZh2fqYgsZCAIabjdpPyXhoh+zCZCYpQaxs03m5Ty6BwnqcXi7lWIouPI0y8ojdLIdrTLBMGsTqN8gTcisJV80vcgP+5zkQCu+w2fbv1/Y3qzRWQqOM5oOZiRkPwzpstjx96ST+60S962heJb0duUfUC8qa1vcCeOq95Oyo+NzfeTmzhrAINBUnIkTTQOJy8PnV0Tiu8O1jO3m3DuKrhV6bpQ6V/Dh8imcHcvsn4K1KQIQ3RUNWYnOSYlxRGzxrwDShbrEkmuhGhFbMMNeOEmKc79Y1ZyJgXNgECq4MQS3vVrEqPXCxNef98L0w+/W2fArKr4nr1YO1Q0PrSMHURg6eQZVoC15oVcYtv+lavihhfCws2BBYYS83lVTPJ8tLhdJ3v42uYZ5k4Dgs2izLJCd35k80v3Zz8w/q/NwffRaOZpB1w9QJfgSlBTR0B+/Yr149nHiyGORuNRefEREzoTiFmBSqY0+XJXlMrRq1twxjBpo0mNtj1KpsbdBCMUAz6iLzN1/K4BxL65mROIJdxGLFTvZSKXluDFQIPazN5vpZho5O4CqWjKvFjEeFuvB5rpj4WhBr2pCbr47YyJCOAjwItc4C8gnBweYrShRCppBtE7DvvcPpzVp6OGdN0DBw6AjLUoaB2PTi9tEG8HQ7LCG116xbeEiWcKbXVLkoI7ziXtrJSVjZw94wuzF2qjWnrbqKDs6Z+KJLVE/6/X08gB4PkG4h+KaOPvgrhu+lyd/SygCAxmXCDSVp5iJOR3SK3NPE+p3vhg/zuBytDP7DT00dZ89iyMXUaVzQlqiVPsgdmLqkFjDeUQc5GSfAiIY0dUDJV9dndd8z+xuX9u0ObtjFZljqtnncBYmppmHszwvtzw/F7y1rV9rj3q0vJTWVHr13rcFtaQapw7KLhhELI2kSPcuggFKGLczLzAsW6LULFPTv62naBZV04ANJW6GFizgUb+F+9y7eRw8XRxDdkKpUv4GC2ohlC+oXkeivk/SexHl+6mAILxW0sC6tx4MGMCjkGiFY4XRNjw4TuBfQEVGERnZrCqn5NQ421B1tHOyFuXRaNobA0jAybiYNgxtKe4+kFJpI/LYBGhsBtA2mxJNiTYkF2DaQNghtIJICPuWiNByWjiMRtNGRizNHpsRi0C89gj3zwaM4xtZ2XmjU+CSMAbG7t7KvsnDFD0me8scj23XB2u9HcjbckIQDoXu22qVFN56Dt66DX4u3yDIYGSDGNtJFlht60VBw6p6dtrp9DNfv69aHTy0I5+YWgW4iNGaMbG3YIiP0MALLBZSPqLJ3oRFXK/+re2nRLNkM+9a2YEDZl+RmgvBtZiD0re36YH29C78lWo+YmzKut4jadnoeThzV8jl3ivYiFhbY3baZhJKNTdzL5PtcDN6j4ciHY5uTHnR0vqeD6v2OAZ9n98ztVVQkBNBFxpVCMPE+q3Rw1dKQ0LyFNkbK0ZCzZZsps0Xo9Xc6bWnqaGOTC99P6Or98SR6mOte15g0wgZ+Og+222o+Lvev6O83ja4VgsmcEz+xCiXXWW3qxLGRrLAmVNkodYgPhd/hmNPsKRZzgshE924pPoUSsoEv20MLkDBAlGAEWvWmclfmJT+lYnpT3Mqhx6ay2bBN78GebKGgzRmpGZjNl5OmbaDNsxhNdtA2WzEhNTPE10FhyrIQXPMgBSMUKm1sqUwRpssJ8A7MDgbvn9r60T+Pi73gZ3UCUKSdOHBG3vdUgyjukYm43U5Wac7nzUyTse03Vsl8WLHGJHhNFk9XJ8P6DU+t9EPnB7DB+H8EpesIeiQ+IQ7chn8L4hY+UQ7DW+KWPfywIprQqEQhRurTZjaUB8BW6TOgcOqtxAXBGB27IiyR0EZvCMwjW2APD9yDyeRq+B6dvN/zBtel54aJq+cjTPxbApcqRVynWx3SWXwgF4W/guxr9Dh+A0cGa3tIv72+Ietx/0Guv6OVNURmoIJmRZ7aikYvCgiUu3Q0tidRjJ8b87U87jh8RgfLYHb+GH1ApSzSQsI3jbbaGX1hQ+Pf17UtpY7S1Zg6eTCn7NGFr/C0JreRnomWUAizBCZoUJGb49aIIsrKv8PKQjJxcpJLExmpvAZssnKNI94hCWxCDGx2KzjtXr18SaQLdq0ZZm9jZUCTjATbUx9fjaqMhV3AXEQTEDDm6XGkVm7ZtaZV1t8/bvfG94vTwvXvjLYW2aL8NbFBoJHAZjpg6aHaiHUvEZw+E4iBqRDD9yjE0Tbmu6nl2/baPujJ5XoZUVrHp3sye8pYrHd2XHgG/+FQQIZQQIIuHY91p21eJPu7yVRA98hFPDBCV1jZhTR2WBBBAMjMB24zyCwY7UsHndC037y3eI0vxOKVVDyMvGmNuvB1kFso56U1Mk8u/c0K9+PtFsPHD8L+72+TG/t67DsYoQX4rdimCECAYLINqDOtROqq8DCwsBGLVp4YGL9volZJGks9h0psuuv0PgDtvXRBBXCMwGkSjlIFMiimECR6pkSjuqnAdZkobQdmuR6lduqk4HI5ngW2F6jUiMai2WkWBgwcabSQ2BdZkRYXs2Of4eDRz7hzsnl8rvup33g9/39UyGbJbQjzlj4+FhyEoYDlpZVNCoOh0N/NLOikwjRGQKQYoZ4dbbRjSSezujd493gZGs6XZe48a/WerhMiNG3EpEsRDd+LA1+zwRuLtoy4z+IDM8bZQuLvm0mtlegsViVid11vy9tLwedzuFPvoAhDh0AIFHHPk04LKECBwjDweobF2ihyaK7dKW+d4pXX/MRNrrbArAXbESH4o5m1272ub1oeqQV2NtQasDbGwV9814iXgB4SKXLved7mtsm/pnZqgiFUsBWlsRcrU0IKLQWa/mIpKYVCKODkc/b5U+bWFwEeUDfq/cnlRPPGKLORkRFNtxGVYRjW6fF0qt8E+u3wvEFEaaKRSKRSKRSOD5gXRIF0SA2H6nB1k2DQ2tjT0ddhGPVZBdhbIjh3hT2Q3XuXMzdYyWgLP2EsCostjqwUBhWY7dewgiJqRoESemNMbUxcbUbo9lpILWhamnabZQsMJL1La7goPTLqdRCgviTJPtGx3qiAZoqAmSncNRMLt8mSndNq+DfwUAbBdBwpvJ2Ah6kDd7vdX+nt/DoqqtZ3W5lYSNhDa0KWxKUmosWVBHo615ZknKlCS3omjpi+dDZFPxEUcFFnXdT1EPho5KPDRZ5SGHQaGHaaGGyiscK7xedJie57kcPG4uCSNxpRKHehBRuFXk+z+dLmnfa240tHXGjGacKbptjGgy7oS3iNAYQRZgYNHVDqrp9TV2Mn0836mPKNzo3b09OU9ueruLR17NNERGaKG0tE6wSaE0M+9zkRoRkipdT+x+zKidox2io7oPACpVyXoo3MFjXlIjj0HTitJbtsaG0lMljgWrJROvajBUOA2NVPh+18zLpXVXFtBVDGqKRN50tq7eO1LCDqBtTBVQuKkKmVqKoyMVTSFY14srFAQSHRxHJQSTo/JMkOzfeqy767fLh0Icvpdz18e7wanl4l/tNJNc7GibzUoFJuXoxCYKgZoSot9/JYjXl1+R8Xm0W37qgrkTpM0bcj1ZuhSRqi9YVApShl+4Wq8Lzo9HoznGrQObRBWg22HJXuti6s769395huKG2xjAp3ptDI8+bY5irYH6UfxadRBTrEHQh1RSPmy5M19yQY/9zi/IfG/uXZ3gku0t85tAdc9TIU2AmPlLN4SGRbtNVpdvigEPxY85qkKUYxhFqojIY0xjvrVm5ZxSF00RlWYwuBe6TiFCG+IJA09Ok4oAEjiezwfK7CEeBxUI7HG7A7A5/YQiSEJ7Bc/BZV2OVavYP4LZYUcPT+LlLt5v2cc2Wmo19CvXYyqNAcwZCmPGpwsQg8NSmSFYgkgkE83DpYNl7d1AzV0DHW4SceOSkW2UYgHAfQ2/t3rvrAesA+R0OTQEXFVXKaMMPj5XT73uZ/PspX8NI4Rj3jLwLq74FE/ah0NKAGI1RNWZ0EeBl6HQCtn/26OjTKrskINtmOnRGAQQ0Q3IdFEsvHuGfdin+xGlfUp+2irLzJKs0BX6hzp9t9r326WI0m0NodVK/FZ61Sm6/CaU8QwKwY2UGKFsOCjT/Bkfjfi6nrV8VhUY9nbIUbsggXi843SOIcgwYPXuSnNehBIxjAPFMA8Y39hbGdijZVlZVqRcQuf4eXua6dEJYAAapjbQ0ZU1eg5ThxXohnWuQnQYdwJBDdsAcBhw6Gg4CwBkt7V9m6zd0WXM6McwFmAkc8FhBQyFQMby9rWl79gKsDF1seKfG345tLrXLl0wZUt1BeadbbAzRtuh/Cfnfh//BIEZ7SmEIKSBmBoVIJiYVu69dfvMnfIxx/p+u+H9n9fJp7/HMvbyOyODq6Nhvl2T5u+xQa5mNOsNsbQ76jKkyhjH9HYALASdx9ibzLBihmh6G/CQmpBZCATIkRio21JFzoZ9zo8S9rT3396MC/97ZtuJu3zxr+x8yyYdjH5DXw1OUv1tyv4nm+IzYS77FvKirjY1WQWQTuLMPwPVRSB9N6jLSQQ37/rVkR2aMEZkW3XN+U/fe96uueS8+XT9pN13enQNg2Nh3LI10XrNFOnGNoDF1a0t4li3surv3dWxr1mJSA/lfpskWZt/I9HyVy5SNIXNFe3XI5WKQtXUIDETuDu8GY1PbHJYf5aOPR9/BLXG3VMzNV9Awk0/iTLFgEyuj8adiIJNBggoCPGXJsLUAce9ldOp9baUnuKIocYgGbRntl2c8Q+TpCN+H7X9nyBMsn4eIdd1YkgDUTXIGvnWtD+LlwMutoWDNIhFKpcVczTdMyJlXS+wzqnjFGzcQBRl5csId3XuhV0upxdS2BwfXgbjrY9OpN9KeTdwEKVv5iEGABQw6QYs0MylLmGZ1oy6CVcWFLMu9PwNrN0FL70RzZfs2++nMnI5d3gcvl1vBy6P1unl1td3ZaZ83z9bdTdaBrJ18tE7CnXr6LKl6GYY4mRWUWhOTigVMKTiBxPAGMQyiGgJAuNImR7V+FB4SZJybWfRkp7vFg3KG/HM6C5r7m/OvmbDPCeDw4cH1fPvcv9H3Xt/Ss0de7WUBmCAAJSpc9XP4io9RfmNqDfsIUJ9mZjBu6COj9/v73Y30f4GHJ4EtTY1PrNGne1FThamHO4c5Ud3EycWjo6nY+n6fken92iqvRRd00aWHU0aBg022PBqOWCCysbnVWBafB2VN47DHL9HmQu7Gz3rzvGz7QxoeILEexswEw1cvlqFwy3GkC0gWkC0gSxawAXoim7IlhRhint3M1y13N69eblo0aIUgCf7p9ll0m+vWcB8cYSP+GEWSHUImSF4SoX0PrpseGBCKOLHWkN1yrhEq4gGQwdaTRbZEe+4NelJLGyHD0FakufGmG5yUHo5CXTLG8s9C6qI5+flxRzeZHUfLLfd7+j314gWRQLPt7t/hbFuoi+0yKKrv2aDZrEMtBvoCi0EtDQgdDZIysnJ0E5Mi2+jop6OjUDRMiv7+/z8+JtRAC2/MDt2iYdgLDDvJixfqxtwNvVpqyKDYKpkGYDNctwp+QrNU3ZyZhngYE7Nw+v5Me/hvZAIYCrQ6RV0eVabPh6PgPzAhlGBqPrWvkVJ95gmRJVeRF7Ua0gcCAZmqM+YpcR8UlZVtl7q2Zx0QH4FI3VCvXElINrT3NYOx1v6/6X7tuvdWLHDja8v/zZ31DJgg3cmZAKHIZCYjwh0h4rpz4jRdJv0gP9H39aS7jtgF31nUZdH6+b4qusZ48lTLb2JOHofmYYY8qupUh6lP53m8Va+e459EtUrB9vIH+JlFcezjJBkZgZ9GCfU18o+otc4hwkY0QrD5tLr6dTba2C+Q39hoCSSZZ+hVaARDIAZrKDHiQLy8kodaQjkyGz2zXOgFgF/hgoD/f/lYy3k5pMoFdFSLOF3sq7IoqnvID65WiiH398m2SUX01g3mGu4Da/9+Lkoq4+aX8Of+f4vIbARmm5/s60abZrZ7VQr6H+t0tZUaelud1uN1/5a3pEqGA/vTyr8++TA0H99bvQlb1H/FOAsY4OAtHw3m9sINCn80LAuvIhlYhap6eAc2Lya1fosvtVltrOu72x1T9HRlMr3kRaVbXL878KgbG7/z2/XVXoIaGQPtw4qB0FjQ1zz8GGSdRH6RWC52BWrTAOQILMsMZs/PV4hrNA5zxWw3rxkdKnio9ZNn3vsi0tNXsNa6lUN8sJDaF8wFQTfT9a/uL2hykDQ1mdWFlv3+SUdFAUTmuUTi5DAZf1nt/q/C3IA34DRXXP+rSOxMQ5GQBlsEWm1D2jnnLmjcy8rLF/BTR3sU+Vb/hii86Dfut112ajxeFZ7B9WayN1vB3+pTgsb+Z3/gwnzxdjABIZM9W0QmsuFvu1MtroTeM2Y09Zpv9jF1nCugLwakCQlUEOMgh3NwQYx8g4cQ8GxwqSxqZXoeJ4+p23O3ifM73/PJBE2hYSDTEL4T+KWDMCAOnMijfLVIeYvIedECxQvImyborLEWtrQ57Iy7sK50czIX0Uwqkm3OmadLaT9LQWUU5KMJ4TA8y/jYCnqgj9p1cTTNgxN+OlICo2RuVp9TfgGv1sB+92+wq1ixfUWaiMX6IzV+YH2PD/1fTu93zufEf0m6lcMNsV3K5eVvejoxmrs7R41k4SK6VvfdTX9DM2bqZlh0+lLeLv8vyB5HkPKG3rKvpV/R7OBy+l0Ohg9CZ8Tp5HP5uzVryEpqUQlhMxvHpU6/DpFikfIzs31gpK2TeeD5WhwQa6BqmVovXdNHBWEEGW7aRzeb/T2v1fU+5CfImOmZdVAGXho220JQZc/iIVkSTQjHuayKJ/oX4cHpdExILoVM2Jh/oTd1mo7pFtF8i0jFR1yF68ulruHqokjpQuXxVm7pmwr9fo/QdN+v+rEhw3TuW6D+U70crRn3Djb6UyuQEpw39j2Ob0ttnbeb55UW/RmdKkQ6RdmRmZy4JVAL9pNVz+s55uZFAN+l0kkyQyrk6ApejfxWH/qOw3xoviD0dBPmHyEMSyHTakZZYLpl57871mefr6XO6/Tpj25GTVVBSqdxUFT1/D4NWOH8vza0uNmlq4jtbddvo6xuFN+GYKi+b8GGj12mzrUoHIAW2d3ReC9uCNwlMZLTyGkIqgVAg6+YsF9PGLwc/bT7yEmdXIR1o9eybx69e3r2/e4L17f3wevXr169tr17fvXr3De4msmr+/w3j166cgS7n5Nmm7RT4Fhe19+U9SWC2Ax/Y0tKHi5GRkZFVZpf7+vcPXD26AIJ0sG+i7kQTrcqRFYhfYgYoDsgaL89iwKJu5DT2rNPa1K3eyfc5iN14dDBhJmZeS7DfQLXpeXcA3OC9X6SRnXJxqrSNk1akF4mNdkwwLJyQIDJ+1EMze+WnscZwF7clpC/Vi0wUhfSJgcdMMuHn+mFZlPNBys7SHqMaG3shXdw+mXeBkAZD0iFsghBIUUG4MfoVvt951YDwWR8SGocdjW6hrvU2IvYvi3B+Av3/X485kWImJhgJprlIFhfO4Vkj5Qm5O/bJibUTafBfjzcpKk6aNRK5PhZiWIeZ34J8f5WMorJUS8PaJwC2HhmrC9NjOyYLExLZXT09PT01JJ5EylpV00NMroc6QMEGW0YpPpienYC7JX0CP2eRu6Oo9QhokP4kGoU8AsDAcGO08kD3L0yXRuzDAG5gwVCIBF+PGhJZ7xGz5VFaWtzZrSzqkQ5uKNxI8hggHhPuIwS/PB2Ny4SM9+hBrHASFwhBC5fUEWAHm8AvzWSYs1Tsy7yr5E10VlRK25BweFky0uVeXnbfgsLm/IJLFxYxDn1DzAL9q1RGJIQR2wLenpM0ohz6c7rDo+X5SOj5a2HhYuiPL5Z318leHfXyV4d9fJC6O+vsysvX9+QjMY0hAClMDWoEMUREEWogTEoi7NTY0OkbF6J/Ku9YuaMJdLdtZjvO0hqhTwY3rpSppwhktWayODmnY2excB8M9eg7Yb4uGcIgrtG7QMEJO/Xvb29rY9oVdLL4QCLjn7PqWi5jACQiWYAaArsATDm7iSG2s7wC7+BJs+MmgMC0tW10p6CFix9fc4imjvAKVY/4a+EBZLVUsqqm4Qhiyt4v3T9NL/FPyFYR/p5MD/HxyLPLw/trPp+zxWYC1qCH0sfzLUKggahrjkPf/pKZMrkMQQXGxzf7Q63gNjz8LHbtP5WfkRYzJD4W62++31BW7dKrGCBwvb6G+e/ukE9voRsk5vkBAkwtMwkhCQZhNCabHJVaCBE8dqlKmpe7zO3kFvN5vN41amFSfzMP4CRoFcpBvaW6wn98BvvN2VW2TUOREgls4uqvAiqUIaBl1cKSbMjM5VUkEzAUwGi3Ebu8t6yZbiam6L5o67bN3AILYolzOJ3GwW8XUxpW+TrWbbTJoJVuqj6p3doBWHF4SMS/dYU9NEhUpND23WpZ8Qp8IxINUAUqkSoWDwAfqB+8AY4YOEwt/DQJYZlXCneWyzH+PierrZiS3DRNO65tDvo3Fg6MzuT0D7L0kQAP9guGC8OHHuQIsyd7ny7txoTYcQiw9wOp3WmerCW6hrKdXep1DhI1D6kJPuD6knqK4ByeHB1YmRMP3/xM5EBJ4Uy80Shr9zgZeXlzBqjfThteJ1/lx4YPASuogilnHE43q0dH0jkhEIFID8ID2g5RKy3KCQZdf9kON3ojPOFsTBTB9Oj6PefOV3DjeNl40w+FyTgUFv0ZyBqJHYrQS4k3wB8fH2Hs4Seo66WhmhhBkQYYLWYmQt1w6vVlpSW3ggJ91LubHnWm7wLqhiKOkmxfcqY38xLyo4k70Z3o9HJ6s2Qd62/1ry5rKtbxc3N2o6/VsyLMFHe5zbTII2s884oGzchP/j5r2rqo2fq6jZOa1rU1BLSFNE6+swHObhQubAk+vhLCsGMOxDcIbuEkk3NWRJpvr5dImSp4PKozqchtS2t/Gz1fKRz3X6oWHzcaAeaX8J8zwQ7IMBgqc0QRmASh1wiAFQOyCVXu/jg6RcyPWz9wzXQHiNl98gEJdkBfXS+6fcDAhb7XxE5KvjVuZDcWrBjqo3cxy2TgAGC5i9QuYclsdVWSqtbUvwHyzSJx+l4DNpeU2dwFVKL91vdrUCpKaucHkcjIlJwssEeOFu7xTPmefc4NmfRnQTh75zBaq77QnGPI9q6Nw7Gxobn12AGYyQNrbbWAhi7e0BtVfJ/VlIob5J7JoBsIfEZie1oCV5BDcKmbBBtpstNsyEHsq1BOUhsh4QsZgFkKoQABhi1UWB4tZ0bdq0IfudC+BFErr9HEooAbuOnfu2aNymlpUsqu2kAd3u97XP1wlGtyO8lKKtx5g+J3oaB2HFhoDvwIvY9vIgYoaOzugPzMwCjYzkFs69LaqkKZz2QH+77LVl6dAagdmXPLcL4vSG64vHjZtKvVCMAgPVNWULDm0/MPHDrthyw+y/EgeDVDC4Neva4dzQ3P0NfXuAy93DFh8v0eYaU3Y8QhuiG0BtfsK8J1youREXtvyrmPGnEsP5ZBQxqdx0jZABqU8jicuvQaMtTPAdLEYbEgGoahaKk243Frehdzz6d3ERQBmGw5gR3sOPt3uRYrxYb5G9OFEUC5HbYsWLxP0ths2Gq5clrdcZa5WwlshCMIR61L3GLNfEhDkEMDfdFrBDObDVRNQ9hm5B0DgC/2dKi2vgRpFG4hQQtcMC0te9DzUl35gmQGZzLe7cdOT5NuSO0kjwao6+mXYJFAYQMMgF2Hgx8xFxID4Pno6T66/fvhwH9CBAgQKL5gPtTS0tLpDS0tLS59VUh5paWbl6WlTu9tkY2HpYnA3GNjTvaHV7UjtpydkzI6etqqsFTOw7xrTBxg8IYxDFxgF/T+dlptUODMwZmYrCridAQJLaX/7Hufb9PoWXQ6EnVh7P3gOWIR4o6oSuNPCvPG0/Vgt+DBgwUgUe6C5fNcHrm8mzH3WXuAZFdm8qHY5nYr7i77E9rj6bBAPwHD/+To0J79qdRh08OGMcOFh5sVUmGCNYEAjszlLFyxIuwUSiWIuATEpSla2JSljGZjYTtGPyjGluaA74So8QDPIdWJ5rNl8j3fte1D22U8wenwDWp71nZcO2pbzOPYNu3o1DmUUD3SpF9GJsJKWCeAPJj5CgUgmdjAJwGrsENjYLAZvOqwj4OlXGmFltc+XFxYHccOCJHhT0H8ReXaZf1qNGjecunkvgMFjM2wDbny8d19uXeWepw5CHCQV3y+jkUW9woYJsEFEPVV5WRYBdc4cJWst1I+DBg2OewTgD4AADn77twfFkyW0FuwkixDvqgGLEC3OrhyZCcGnE5gYwNJ1CWfoQDBgzqpBIADR17SS8I9z31LIoBwMYkhq6t48V4a4H8LplmdOYEGDpOFGQi/z9teuNrFjw8Hwfg2QC4RlQyoJcBGO2RoIVYkJu/WHq5igs8rlY3rXQ0gBJMAqZJcsZ3iGQT4JqC9eBC5+e6Bb/8+Ij8Sb8L2HhIevCQkAGd3v4CgI8rFvFDbbz8WcjllY1OGWYUArGqAo9diHkWrq+z5T+Zoqwd7k/gSkLaKi4GhxMC2kG09ofL4uQ0Lajh8fRxrrxtmZqMiMjJYCQvVQDsTrmpx8mXnbKuv4dSXIG+5sTmQ3xDerbb+fvYb/fgPIY9vn3Oni3JDtZKj1EP2JaqsyglURn3E8Do411fX7vEm+yEBcXoiO75PkcZWvVRpu0BENTicFl0b8RIL0V0jUrqSpskpCThosmuOb4rCl2Q2Iaujjr4oghMqMayEAgTtyhyCo39Rjfb7XTr6+vr68ajAFRh1SewYrBpAZ1zCCF7n8z28Ceip+2iPxnKqlgASKfHWNEzPVIIiRepePqtUwNUEo+FTxMqKEC7BOqv/VWjrq1Ab7qdT/xcst3xCAXUME1Oj08CTbUI8oQlXN/VQJVeLyu77Xs+R6fIzu1DkZEC77qWr7wlmhybVvyb2MDl3mS8OdzOdQagkXvaAN5pYDpDmCDBKcO3sVuP2PH8jkVNTkT8jkcjf2LTOK4XBwA2es5LnJI/J5HpYtLTAXMDnhIGGGgwOzjoF31vI23gZUii2O8aJXYXH4+ejjix87j0oS8n71PjhyeQFeRjbTZY1oGZ7ztBrx5i20irIbF04CHWR26yb6e3T2wDZiiBTAh3zghYyfA7DIKMYkWODcBRaMoC0CD3oZd7ytTPy+r1NXilgshdAMAy5sMhYVd4r8AYSA6RsGYx0kRiPNsdHLvNTPnmgg4avaiyQ7AY4X92EuPn3vD4ejf0Akc4GCRxAgHlgMBhAgQBgeUFB7oPBDABb7ieyyhlDKDCBwAYZgYWDMDDywsFguEBgYBQXCwQBhYIFAwwC4XCgoGFBAYUFAwICwC4UDDMArhcNwHN0MAwN31IX1/AW2hBsSkyPIz6fFZPRAgmHJ0K/GOSjWDk5y5HJ6aK7rLUrquAf4CwNBonCSSfES5nXVyJs35KGWkFr1mvSwK9k5WZwAEI7XK63BqcearXTY2pIQeRblismSN3J0pwNiMJbnDx+Ln2eJZSCmwdNHCt2cB8CfL18XbBsMDiBxdgLlKy0g38Ny7qa6kg4KxpMjwXxfAkgZb19si4XwLTlMerfIYXK74zOEaDBmgxDk3NWjVTOksgeT5MJ1wABCd4B4KIZYDwwQFG6I6SBJL6DTYDaBNoRWRkTIQOUfyPkez2fkeXsa1ro+Z5+GkpbN3q7/f7jJyte+vhhTbgj9EIQjU1tfpU/5VrbgHeAwR3oWODEEdAJAgBngbPydK929f2j4ZUC5ezEFcDwINJZGvLtSwQwmNnZx0bO5Flfc/7bIZFpZIyxWgoNHAe27PmeP4VtxlDZ5Hh1mt3Wl3YJHdk/EuauQMbwqxGxGDLpjMAt/trBcyl8AwS4IAMedAsya8eLz8byw8wnBJ2jJRZtWr2SECkxK+/BgipewRJFkodwD329mmDywr4HTDlzYPAC9pSAnJgAzIPDJ4QWoL7mbwXSCUZqbj5eHDhBUFYWPmsq9XEBxqsqbbbd3bUYt993e73Wb7lEb6FJFt0Uur1N13fIDg06oKYFoAmAEBgMGAMGFAwCgGCRQMIAwYMGDAIFBAAgMD1vBy6x4DCd4DsttjZKw22vY956279fw6ZSyuDGCbcGo9LiZn5nDk7i5PuhLK1uFt5DeYJYPB73xe3vKw0htEzEwgiFxQuQtyb6t08mRBgMptjKbGDV/GQaqNeq5uhvckWPvfE/f5PV+3r/TOAHVrmlkWotvlw+cDDa/K+JHGlCfqbipphvg3wC4AFwIDBgwoOgFwuHEDrBgY6+dcEbP1kgSEB6YMgIQoKAv4bOFgORcuuFGYI4D9xv7du2Be+/Fb3er0ey7H3/xngD8zMwZgoTWzilcCqhknprttPSD/ABkXugen+XTeuMoq9eI223C6VOSRyaOtku+uTh1SfRjqBTNUrangcwCJxgmAFDG/bPB5U2gsbsbYxth8RkPYXqzgrIikg2xypVoVaCdoARhHGhWkQNx0ioQbckJJG3GgjG0NobY0NttpttNtttjbbY5FGNtjY2NjbY444447SqjbdSqadNARtsYWAN4xjaaQjtvEqSSSSSSSSSSSSSVktaSN2kkkklVUkkkkbqSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSQqqtk1UtzhkYU8kMQO2ea8N/em+V6jtORqYDIG3f9bjx5m/mHAPBCowdfwel0+fevOsjFKN3fBauV936/1wfxh+Z5eEDG7nPHhnFMIVbslGjRqXzGSDOsG9lzw67CVvCAZWNRhZJguxwDeJp3CcOZDC1IGxFawUwSsi1BQAcgC4HSvxKDsjoh5fEwzZgDXD0QtbjwbItKAMVyKKj3VvO4cnOkgNNskoz88Wfn5833p+IGlYzQ05azek03GdcnNhJcThGzf0+LMiOPOJm4efDmBbhFS7yKULZA0t2X1NhrS0NLLNhBB8HhaVszwB54h+YyUr+j421GXu9LUnEARMAwWGmn8RguGYBlxmomNHtaQLRztHh+z5Hke5qByNLT2o2RtQI4yLa4tPam60/wd9jxt9xG+XbKrMXvWgK4mlt/dfFyPi59MyBqdkG2KgpZkKpFG1tbXKmVJqoFOGhysrM+ZbmJ2lrQIISsC04rX9SavINpjTG2kQ0dLSXTC1l/Dn1Y+vZM8NK3LuUXNzC1K3RAg23CAYjKTfm2Qp2nIw+BfJbdVXp6M7PG/Zx/8/F3Wlh1zyPKbmJK6LPYnmmw4AxqcbQBa5t5zOzkx8L3fS9D0M5BWe3gXQMejqampdASzBDzNTpavMda1d0BSaQUxcHlyYO7agmMWtiLjevc1vvx+fu7B5P9Kfn74Kn8nADgadMt3Ab0oRQ2JsRvN3xPrSJxI7fAtZQCQIIA5DOFNx8LZzUsBvFhFy7J59zlr4/r9P2PY9ae4NpWIKCs3+BZwOV0ML8jvfb5duqbx2LOCiIiN9BCIRagt51911N5LUxIIRUkgC/H5tQ6T/DeazCbG4MIIJxAPm0iAzZi7/U8CZq6vht1arodF5mAxvpZmvASk26lJOKaFgFAghUS4k4n3174W3Vdk9TlzJzM1rRrmfv4BTSBsRhn1lEwaC+kSA3s/O6J0fA6U+QBn1Kwc/n8/n0JTEzVqJpvR3lWppSgI3vzaZkVIAwabBUCNHRzdHP0M3yXo2Dn6ekGpYRfhMAZehBZ8u6+t61EuBffGtU6elo138nTv4ztgNkrR7YHZ5/Mr5PL4XtWZUMVNICS1rfk/P+Vd/Xx+/1Kt7hBXA8ZgcSuSHKBjBsGhHbtIIDEeP5xsMM0A+OAHND2QS9APfh6QdII1QYFMvKgGj0rGv6WvsnTDiHwOJd5t+H1D5J75Bv00n8QfaD2BFQ9yoEBUUoQQeyv4xGcQxFYI0AeIilnXhmP0ssmYljQS0ifHEZJVMGYB8PzdgA7Gkd86WjvxRD8uOMI7juzH43WWadx1ck9OpN0grxbbbejZiFwQc9o53xebqxpX/udOrSl/I+vz8XyXJDp0V2nh46DJqXiVbnc7nc7nY3O51FZBJUwiQBPdkdREhhd5RaWoSGmltcDTCRJkp8Y1vnrfMXNtiIJXR032mf1PlOhHBWcBAurNX6hNZrzh7QHFtX4GUAaOWyrs4gZaHhi2NTUFryC1ZIzas9//n/p9LVA+A+XMpKAQ1DE9XXTLrCy0dgIMG7CM17kt4cf0ACfdZPb7/4D04bFPYsh30dYSiGc0L/5RlWCe02RDfpKsZpj588KLnp6zOJoIINzYc7s0kZktvpqSF8HrUeLk1t3OShuCCVNZ/DlEYAigMwW3r70zgIXAyBEOIDgguCCCAClZQA/jBYdah6Yng9zJFGOQzU82Wk/GWh0S9IpG45/P/Y1eeGxOlIxyRmwONzid5z9/zXvdIDlpgeEcc3EprsgY2qcsz7c8qU6VlK1WS0wzhKRK6EcHuOV9DFkyYwhle9g4yQsCPbDVVnS3S2zTGm2FjUAN/kRV/qeIwyvI630/wd0lwv0xFuoFkC0wMcl1wrBwgjALQiQXJEXWts7cKZo8ItfVJQ0+1ed+Rs2A7PH6i3N97oLoXdGolcDch4gNHaD8tGaw3qwoqnbUoSB1QvksYvEKeXByE4I+Lu+LvOb1meUucL4M8psCDWYTgDQgWQVlIBKTWGFV0EmuGsJbHEeDT6RweRZOHsbK563nP5/yel0AtXfOohpO+iQY0zPvoD4A8LOCVCm00LHQpe+fNOc0VwwKSFg8zbFkKVKCR1Me01ZV4XUCZZbAbDcnDvjueJeC3U0djo9U2+H2+HTXSTX2UsMCx3Rv5mlCAPdsrMuIEQQWGCSgiADHPr71YTy1gk+v+CJS3mY/hLh2bcVR4Lmr9D7jSrkmyV0bKtmERcxBNSmCMFYNlVcvDryFfXsq+ioOYt67Gzdsbvd7YDpQhM/vukps+gkzTOZUpTI+xIZjKCwkrDChDdrj3k279EVql/H4niCeVQun0Ja42lhveiGvnlZfcgzg5ely6bH5OnwVjCm2/E8OCfY3h1qTmL2ElwjN1EqSvMV3XAZQurlp6x/RO19JrBKLZ3vlwPGLxsRWApAm3hBriDfw/W5XjCNoR+5ucSvYIxu3jcgJZdPO36WzxMJLRCq0CxARF+KgQEgwMGyZUUJmONNoyFOZMAQArhqalBqY+RqOG7wAbFCLnNr9e1ZfsfWBIAxmC4a8HqCPB6uwkxHqSHk+Tb8Tye7PFDtoN+G6EU+9t+8jwK4DBiGWQtVA9QRsa4iUnA6JQksPDzlBttNoo8jzJDFbaG1jGAHi0snh8Xxf1fjKifPA4i7vsXjwHvocnjqRDiAucYn6uhMcXm29Qp8akpSPdylEJMytuZDYrNXZ2dnZnvgapEnvfwvx6+8v6KRYUGgzRfT2YBrCOWtZrf6fnSCJRGB8HfyWpNLh4doXdtbn8+BReL6F6IPrEt0Cxec8x4dg7GS11C6hd2P/vrvG2UCGk4RtzNMGni0jkqjmRbADXFarbyRSDWbmmvJliO2JU+SI9WlmaV5ZJVwKOCAegVAH07qOgQngi8vS1PEqQxV50MPoU1AdESBLd/rr0CWEybHx2wBvqk40DGLz8oRjZVeyIxwlxgiFV9Lra/1bOOIue3sfHAdgnleCA4Y5Ere9Zv2iakvwWbNTg5jGmNP4+/0ZxnI9UCg8xG4xc/U2ObexuX+JTemdOWOq+dXrsDfgwNwoqAmG1qBmQFgXErA0wQURBbSpqqMaPipaCEkNFainb4z6VACgNgDJeaBBMfLoRRrARO+i2CQZIFnJjkf68eTluUosWJqpKKrOxCc/vtvsaHv0EYTqTVUmjGKQhCmNa1sHSS58JoSxz5VUpVQ2tTOqlKUqfSCorjFy20ox1VIRlOlKTqoxsnzjKqNKUpGhHGgOcjnFLFKWc5zm90XRhGLWtBtaDa0Nak0Ma1i2tabFpYyFKqp0nOlE0VNa4uo4GGioPFBChm1rWtaxrVNW1bWxhSk6VUexD5ObSqp9G0fubM4I+h8j4drd7PK+ge5wxHKrSLtaokaVVT6AjRW1KdqUS6U/H9XydDGYkbxVSphAUhSkA5+1zNoN+GkHA4VbxhKqFYryYF01bt5rT6GEu97Hl49CoI7uQ7AFL1tjYorzmoZpYix+hj5jvzCOdAcKHYmZr35JOATGiDM3kytG5ay9Pc5bS0VmiW62hYLPt2p7WaIOmtFTERQSwQJkgUwpg2F2KVFGqqKmDkCZZGpUCmDcYR2wFAq0CVZlrBaggTTgRpjTYNg2nkcTYNg2mNNg2DaccTYNg2DaY02DYNg2DYNobBsGwbBsGwbBsGwbBsG0vzWQGwZM0jxCEvfW4fT8LXzLvzLUdxX8QCjGuu9PuYeYQwRFEUzZviQZgg8aXSlyBUUQVpANM2GJCXPqMpyjgGk+AgHNpabQxYcZwUbDFVEpEoDTabYMYwbaG2NDQMS44F04MbbCAwGineIsXY3B2ZduCQXtCoAQWFqToLDScQnHGQDtJKgxkqmUkDBwyIBWBYXlEabUUdqpUm22UgIFmiXlgtazpRtgmwhTsyiNJtMabFisEfNSfU6nU9Vxeo7smAAbu2DOMmZ2ZJAEsgGaCQan5VgmIJ+AS3bKfs5fZ7iyfMiz1wH326p2s2oLVsF4J1HOnU06ytn/mwdJilshZJ1LsB+iHBx0XHEE7Axvc3LOZy/g/GzqJpa2PGGOnuRHcwvpJgGEZwkipA4J+accO6S90i+5noAxcEK9apVDmxO4nLqUOfU0zn6H1c7EpUlQ+VHyttDa2tq92trG4fI9XlS1TKrcaOfGD0ILaaJndhDKEZiWYiQMsR3wZCFlGYTwy9EGQETIvZAvYoONw72slosz1q9rfVSaYYdq6lW4aQAj+qv1sHCw05mPqyeUVVgQVXeAaysrJmsrl/ltqmsH+/uEbgCOIDB3EIQbdRRMslIYXCxnnyI0M22fieClS81pzQwOV+Uz5gSBCb0QoUgpoG7mTq+C9L9k1pc9hJ+cFTTqhZAwQXAGGKBALbkydzJTBRCBjctMJYT4vK1dXZz8ltiE1g0mb15HL1zEEsERlB20LJ7YbqYLbO6swpCXd1+JgB4H4kPi+v+J8jsdNH7kdvGYQ/WhdtJOvb/VFB+m30SctOK8fofr/j8ra++D/51GyjOOBPe1DRMKrWP1xrwLl/CSVvd3XpPBmD1vouAGWF1Pt+prtPs+tKWkvk+pnYz7v4l0NOOEpbtsvo/x/Zj/H7GvTlh9e7ZtJdYlwZZcLRPN/6+H9X/v2fT/V79Hl18oyZd6M+lbGUn43xH0qLytWH7Wf9lVZE/8xC2q/r7q37AOJ9nJ9ViybojqHvzc1/Lx0fXhPi/DQlhwylwnrGSq/5lgZnCGLdGiEh7axk+/zUE5EtvVpFGKWvzklb6BwQtAb5Ll9KQ5yoKvQY8JjZXIVzDFev+ZiH/hkZId4baIv29ZYh+Y27CPsRJvz129IE4jyx+pz9zUCpCJxBR14tIXTd+n9XFGBBkPx/Mj+j8TleU4FVGyRDVYwgFmGGjpKS4yJaFNINiwBSiCnQZlYnuIOIPYf5D3JJwc4BxBSXIc1q2gTcQ7z+4uEDe8DUWBCBBtkGPU5rQQS9vD1dWcKzJsSlKQISj+7sDQsgsEnS+A2qruMDwJQIQIYYxi4VPaQvgOdkjoQ41XdjdndJI0lfpChCgFKUA9nmV12ogP4YLHHwFKBfNW3jsttaCZc5nE13dDoCFDIwIxBRo72kAtx+R+jz94N5wh4FKFAE970gkaCbVrfOeWQNzdAiRa05jHPS0hpREYgQ+B06vCz5ykFkBER70Y9JkY7eMRRhASEoxjHhCEA8ELphQOENQDLjGLSJzg8PF973R8zqxIcWUoiEIZhcguTOc4TISRKSE8aJRKEIQBVm47sPa+mCHFhCC3FqwhfAvzjNwLducqwMsKwqh5XnSkClKHIjEolEReChBAgYnOPtiW5kNkpicAUYzlK4JRiN0JCUgUpRLjT2BKMSx7WplTBTKcQnOuyrGQsAMMOM3WFYsCD2gmhqyC7jHjzXAnFAoPAf+k9vMMg4MAzrzN5Iec55uMn11KA+mrOa0glYGcQSo1OWAshm9UdXdcUPA28BCBQIQYSTJYWKlMLRa0g0mtYSg5a16rCyolxBd4PP96YE5lOIEVkK2IDDM2KYBEtELCrtGCAdOfwNGAe0Bt6RaTLjWgNbBgqOwGNFLqB5P4j6DdUoK9TeUrpRNKDmiuuusVuiIxjACEIQEK6xXXMS485gSlISlISlSh1GVVcyrkJDvxOZTnCEBwh50RGIhAodLSx+PuqTIWeZUKqhUKiqqnAh1GMJjLl68irKgQQlriNyYhtljyuuAd03veT0sAYxnVaTWAMZU4OPLcTsrlPJ46bAGMUSh01gL3qiUOosBfR0FSqvIpVUUkUfJvqMKVmX8cR++qtucDJpZYFhzgfJ16fHomnZIMow4eM5RjYzDgpZZ+9/a7ExRLySMY0tJQUEbQIkuHC3Y6aAQwAoRUgHn3Y/CpcE2wf6IvHWdfYN+/U2VipJX7b6On1FVf3r/XglFBXs01TiZhV55CkKb/FZmREw8y5WysrYJOHCHDhWQr5vYYX601cvHrz9sxZjYz8OtWtPNhpVVVVVVVVacs9p3YXd/2cW210b5a0d4yVafm72XNTB9q/ZamGBb8mjC8bHrrQ/8da4rPXmhWmmVaVrzwc16ve1rWta1rWta1rbi973va1rWtVVVE7+qOxkISGWqobO/kI99halryI1GDaMW2jfWhhfQ4fyvafM+Z8y17/jVmVlDjAjmd2tsR8mFjyN7w+lzcvY28FZq6m7amBqJgTJljY51LOpTITLLM7W8yM4ljYpxtsbexJ+q4b8c/xdnK3M/I1/m+sOzDhh49xHkGj+Yf0dHqW6dWIKgYSHqLkDi+rhwQMLNaoV5zONYh45RjMX/pfdbeuCHLwRYjg9+HSOl6n5I6hsOiLDht4AMCP48OT+j2MnzR/bpAZXz84ZmeKyaUxEDx0uL5ETH7arybyWk7s+LwNXI+9nf9m4f1NI0Wz1zSQubdut+vcXs53RZMyBo1uQVEtOTb6KP2tQODp1d/Rrf36+kFmDbbY5oQNJ6Pye1t0k1X8x0UmkkMr105dNEug7nqkaZr+PEpBDk4BHsS0nXzr/oef89mxJnvOJQajbhyYGsyzEo1gz/G0izA71hLQRDBAit0TN1tmEF7s0+TmAM2Cz6jDN7mY+qRmxtJr2TDIqOv1e32IZfmhCSajGufCPfnUprsHc/K2eLnv9qPj25/qWr4yLY3Vzc16BFwI5j8jt5G2LNueNmMhjPKgheSw5vVPO2trwQG1aEaIlzudz8vfgDL8PsM8kfa8IDbFngzN4LOx7e1mXsZXPGbtmITmd+cIKw/WzY5ogVOrbZnhqE0lH5WgsMIPMgkNeLVePuvoGwtaF66u9VPBpdOrURqHWdhzPUOs+mcz5p5J/nW062COXuaxqyU7LGRgxZ0LqJZU01JzIQsYIhoUM3W9x+p73c0JqNDTUffQu35fM3VIP7djkTOOs4/USpWsYGMynqQTgE1EECdNo6lM51OoAEUaiGTU2vudx/6taylzgm/et3M/jQmGYZpiS37aV8Hd2LvpT9q57r0Orf9D9at43serUjxzMwUqoh+YEswUFdE0yBwWzWxmalLUCZrC++K0R+ma6fJSmR8i3uPR8nqq+XgfQrTz0rm8ZGz2iBg2tlIhmEL9hDT0DVQ+lEUVd/8os6OlTjOXIu6bVnU+tVcKNz47gVe7PN6nBteDPbI8zKuXh7TI2d2cQzMDI9PF9PW8XWdanyfNh7p8DQraMimaXfsQkBQ1FpDaQe7v7/53zu1/cwfNpeL7rnwOBynedwi2xNix5CTH4URsZR5mOKTYmwfCgRtgmMTeXfP9KEdNv8OQbi0fIZzMnxJqVR/hzmNveZtJmUHL+Lz0IQqq21764ujnzQYhSDyR3Z3V8Y7QoMSJBU+4dTGkqxJhY0Kb6Ia8oU8kODpf4KNDCQ04Rja/dMjTf3ul2vyLYT7FCxZjlk7GR4yMexrb52+c0GszSUAN1mi0N9ALWiSkgFqzUAhbppIsW66hHDaEFmklqDS7/+L2Hw7VBd4LiGJE60BcmgUtIBiHRNppwA26JAFDEgQJTiigJBenIv/qTK2a9d0jSVNQwL85Yrj5RsFFh5EBH4JAxLTMbCUlSJgBBCFj5+ux9/jXCYWV4O4wLvr9XHwfb5uf7ft2UYVu41FCC8YAajSJWJLJARguEZRw7rQNLT03QL3gf33ePSzAUuvIe50nXCxzISCWPB3THdduKmnALeEIRaxG5cfB/P3PoQhCSSSX7/iA8EDIKZWhE4xy4YISrE8AGoT4Fob7s9/7yvLPV2YQDQfdcfRjnzRvCSKXwOJH7ZjiglvgN+l+r7S1bBsYrHms7Ig6CtvIKcg3zsa/37T72Pe/w93u5cSt/heW9o+ytLuG+PsoKY+jkbKT0vBvNHR1gAKt0dDRp4bRF9IP4hG/J8TqKgDAu8RzH1hn/xSCZo9nRVlKBP35Bfs121Hw/HcDotlhmZ9RDVdq/DgY8KveL4KcIyGVdgNQ8PNYWjIc2yJK6z76SupPhbSYl9Ryn0zzpfVALWVMw3u2g+Fw6AYDAea/UUKREmQh5KXm5vEMJBLHtdj3VTxsAH1Qbm1aesBQN95sCxmd2ubv3fO2J+5atf3TkW7VtZ/0KRPPXQPXW+bxesrJUHN8uKdrxOmQIhFgjDiwjWxN2awgk6kwUwJ9LV1Ajy2UQbbyoTw5FlvV9ryPxszwvHc5UaPa+l8Zw9Qw9g5wEgtbTsGQIs4gDMGh8IQeTFU1fXTEk6+65TklnJ5lnqtrstrm67921jc/O7H6vv+dWwEMRynR3N6IR06hCXROeAUhSc5QFy6AUlIA9ppbXzMx4no2k3SmeUtbGnSUAog3+QCvaNWtilqMKUwHl0ldR8XFyNMBwOZd9HYDzaL9t6PRR5P8xx0k41/rIaVevmDrtdf2kNSQ0Xg3NvOUo3FKI6IFviWOHtZYnzDEGBCc2nvG4G4xTxcAvnHhfy/8aqmZnKoRI1OR7U968Aq0h6nekDY1IqPuyYhTSRVyzo4AhsQC0DBQaSGxIbQiDRBgg4DENpDYhsATaGxCFGNob/1/XP+UbYP+pd/YPz7DylKsAxvSMC92FCwRMHZolZEMUmRiwLsLwTChOqhMawQXZesMJZWxttttttttttjQU7mr7nH4+LxuNxvX4+663r+5vtnCLLw2ycnZ9n8/R+h3Hb6rZ3sVNhr39dgg+fXNDnQQ27wcQfoqTgEtHLkZHodrD4PxuHx/lW3UkK5HIo1hyLNl5cSnkIRAT7CUBs4ue7nwZ7qs+RPZsfp7M5cnt0fR/gkAAOoGCWX1Y7ljbY2oukl1MiTPCX4mjh1MGYPQo3HVX6pqWAwaec4eKtq3jaBx3qMtd1TGrNRkjlPL5pa7sxpD0MJWrypgNItGo7ymNg2DckdRIzVaxaoogpijVRVRVA4nmtVWEyCteyLuxkYQaKwlNibFUEVQoFMjFJIyqcUFXafz7BdvNEXaKbkSmFONFUymnVMUjoVIqIeMpFWoUtVGNqd3Z024NlSNuqlDbdSNVhLu7G7O+Vx5JV5GvkmxAyO7jkZlhjTMtNyNxuBUIWwcwtg6jcheqdYFO9S1nVorFpCQgIUhACTXMjSAZj23Nrsd9Pp06NOXrTb31kQOaJM/s59cnAkcvl9VSqX4Wdp3SjymxfKfKWXoyMW6xb6vjzZLc/a9HJkFTNut1uoUQsuEScUmmBVwoZoj970k5DMzM54Q76ftI+WlMcXC4of9BIN78OjvjsnYEUKd0TuT7HBwdI7o512jtHxLyTq3wD8l2Dxjy7rHnn4LtHTPFzyhTuneYfKOodQ6e9t9m+teKeOeOdU+Nf3PuH6zyD0j0zyr4t5V9Q+UdIfgn2T8s68+GfGPeVdUMPteHC85Ny8WQtd7EQu1+WoVSVdsa17SFQ8b1sa2PBycELmcnk/O5IHKPozx6fFKaXDjuuRJ5Rk9JhuPOY7FqpW50cbVKxYRrorWV+cEWkKCLSi5NiHS3NL9BzHXaqtd78fGN/DtDDu4zW96L5BTMbWBjMKefxRHTYsnBib8qGmpuk8udzB5eRkDM/M2YE9cJP4CEGZniUL75EnZWNYmQuBLmXZfs1atWvRrVK1Z48pUqOUqVGjRFGaI8X7o6ZTB/14/eVOqi91KAPwclII20GI6IqqqbGFUU0XUhnnJ1Sqh5qVWoW53VvT9ltr9Ds5FlrLKRowMuetmrV3ssuiDYpJdpyBWNiG8kKTo0gFI7paWlFK7dh27sati4SM9ghBn7VY0USFChHqimpqioh+YB4C3zvgzGHpTs7OyE5OTk5BSAEhYU+3pxOL+r4HI8D6fLFDRy9fv+47LtJ0LLcA6VzLjxjHjbZcuXKc/M73MTROfBIA3z53g+B0/Xeh0dPfqq6VVUYMnIi9W7VyaRTF6zJEUwbFNBKCBsbGkyLVZo9JoF4XheF4Ui4Xd8/wuxwA8N2LHDm2H/46Ipf0izK4DYrFtYW7b5gzMzP3diw2WsCT+lA8G0o2ULOzX8TgUT94DRC+srGSe/sgA6jKp+YRmxKM/8jBGRgiooooR8aKz/r9l7ewF7eyGhI8B7IxNYiFtoP8NxJytytlpbj6OhrHq5vIc2wrv0gC/aCXOOEsuliEFGl2LBWG2oq4Llwf2PFzMzM4nz+Bl41d/bqwfPrVq1CrVpVatV0XBPF6fPKfr8Tr17cp9x7fNs6vE2k3LhD4jVq6V269pPsUm0tyeMhyRdrpzYBmiAyTlXVm9TdUsnnW2dL6qBTlX27vshnepp+wEkptemt8IQheSUyAm/bXY7HfcDpo1NRXg++r7o98YuR6tHCMNf2tDjHjLG5vNydsGZmZyAEY8aGuD6EFviDh+PN+G5Ha+ODMA7l29bu3oV5Sn1xSkMqA+fWbWRZ21/EFqwz07L6bE0e/cS7Nka1q1XAr+mvSFLdfYevvL1PXeWH79xo0VqNOrVRVQtp6etwF8G+AecNeOCHofItoKt3a2+ndrqDXOmK6xNeXY2LADC9jRRcIMzMzu0r7+zes+d3rPZwnTXMTbUqRsO9ivZs1q6rNmn31r0DflF1uSlgrFhzndOs8OlKcR0lYsWK4Fevycrnn9kK0f5/zT9ADiebAgisYrjtlKsqCQkYcDGivo0TFlavf+z+tw5PQGvWqatlIsCwFgsO+FAb6BA+nGGyYrquFcueLtK2mCuj1NN25JczM0eLudi/sIwwGBYcQQLJW1C0LayylJSlPhqZFwLc1Su33Nft39e9t9DlN9fkuuF0tJsJqlbneSd42LleTEr34Xxvdkz5JbJXSw5G2UZcqlZcsvIWn4mVCXWmWmOrZndZjFpvzo073uK+MQcYaDjBQu37tsXBxdzudy49NwPbpFIUhSEqCM57QolMp3qm0tTKmPW/QcLmZsmhrQ8rbJe2rFXqitWKsVfdQqVUaNexesLrWXtlWhfXUoSEqW19d9rtyjdvrFrFrFlK8I/Z9hIK151tZVSnv+7OdV3ywncEJ3jZUkqkknW/fqEEpNdKe78kfApwa1iwl8tUXsO7C1ZeupQZ4vnsn6CT9Dvm11w5ozdvb29xu7RMDq+5EYuDwOB1j7Y3aNnd2AK+N4yvMZQZmZpaAsXEPcQwsX5Rp+duGbuDmQRBFpaAHwwDt1Dcer4yzeBDnPbs55hQ9UqxfTZtIShystp7mNuXA73icP2/yW0CqUIm0GmLYti2XF4og+HLKlcd+CrcC5YFs7ja0diFarJSSSSSSoVtztSJQ0Vc+4iPng1c+fW9uB8reVOfVq1atUqpVSqlwJefXRriuBSsyGNeKygzMzM6gpWOEViyiuBOdmzYUlKeqo1FrLEsA4mY+77EXNbW1rl6/hD08A6wjSM4Guw9VZk5OTkxJycm6AqAH0CQ5UL0uen3vI8rvb8FMgSUz+HytoQV8zuntz/HyefM/K+p8v5+YX5rAzP9CeAuf3W8sde032b2KnQ53I58qqrlK5tiT2aUalOUdKiMRijUG35XNkKGkiYBgGxwuEb7gcA5zo9rSxAMvkpNiICSiQMEm0RpDYS2koMU842ETQNpCbBNgdYxCCJgJsBNghtIXjSWHH/NBb0JTRUg2IQDY3ZuTmyc3mzm829c3mzvFaDbbbbY222237mRtsbz/TaFAPZWOpwDg9Q4Hch3Pc49/9jLOLI23ocUcnQWmaelj6Nu1EtKofrJCHZtdK86Xk6ude58kAsO9sELcse3qmrqmndVdXVLF/NGU/AlkUZQ9SgrRPP+uApDBQLQ0NDQOoqE4Teu82p4sxHo9zqFXsBzIgw8sZ8PkFFIgVn1YnxURFXKrisgzCTf2Qh1US+BWTsWBYXFWnVsWBIWUE2FKL6S1Ptej6/S6Xxf2en13o93Gg1PaABVCIFUwDyiv1NRGuO2iraFjMzQfSpd/iGLHj8zmDA6B3MghlQDJaTEwJyTcauUSlUcf9K5b5nKrtvI8Flq5ItXHef19OV9LnNhT7ma3NpawzWKIYcIwefXu+fcv3gjwLl267Auitnj17dq3sXLNy0iajXjOLOi1ZtWrUCtWdx61m1algFVs6Wm9RmFsTPuW2NRgzMzNn2tS3aHO+Fb5XEb5e04GUAABvr693jYv4r1ZA+TUVgwfFNMdbrLCzr7e9ola9X3ERURBc9I5LE/aooV/bQocrZodm7AIgAAiWITUeZKmTJITMXlqiCSLLwAAAAAU7NhFwSxFir2lzMzMzZ/8NNesy03Rf47TcA5cuVIiiPHbQg4HpXcy7C3m/sy5cLYcjBEhfwx/9cn4Ur/dHlu7DlKXMvQez1kZvXarq4X7m86vB31Pqt9bzkb7fUH0npS4OfBgxoRjq8DSnaS9JlBmdg0es71T9Sv0nDcWBYKKqq4/6Ic//qv0WkhsSPAZ9pi+y7M9wxIw2dmdbzP4ffZMvuJGhZ2jO0vrtpaTQiXbGXaV97AtHCzLoEVG0imBZovdTTwJTwhV5LKMs4xtCMjVmWZYaqokEbcvBU6aRHGknIKSJEcYEkBWBBVUpIhExqgKZGIjIxRkYt5cBEC1iUCCpTEiSApIBJEEZGKkIJVKSANhHGlGBGEjgiMUaUYEYIjRGiNSNttuRqSEajRGowjBRqNEajAJG3FGIjUYRhGiNBGlGIjRGBGB6rh2oC0gSQCRxIjSjUcYkEZGgIyNIuADBADQgYCTEAwEkHDGCCJAMAOGMECggN4QACDYANIFwxggiQDBCPymCA+YwEemwEt+wESiAYAmIGCAL5dhjTF8QaT2uv3vF398MGpH8YdKpVRjbGqabSjKZW+7yqoKMzBma68FmlSc0fgERERaPbcPuIEePHj9ddvcd3gERw/dMM9syiMhBqNEmf9WWJfTkyXclISEhIbbXecfk3+QNccZbr/b7pXXyi7+jRo0eqOqOqPbCG3pRo1KT0A13aZjDGUOORyJLSzTTRnxzl440aNG+gO5AEcc6bjaXJN5/h7W/lD5MJG8gCkiVG2M7D6I7IAgQ5/RjTg3WAGQZZkyYzMmSzOYcy9yuwdRzPtIO7UBS2eh2s/vBUcXOVpzfqA5zqb9EUQ001FaaamymknuJ05O4ns4kyVD3wXpjaP51s7CLPgb3e8jkYF8tUBJAoqpJ5Ngs202+vgETBjQNibbY2NJo0Ri3zRpURAxgBjmTJKor+zZs8+io5fOkW9JuK8qVKrxYEpem5RSeT6DHp80AEQBpjbG22m2xjTGIbbAQ3vYRJDG2mmxDTTQ0xNsGhNsGxgwYmkwY2IaTTG2NgxtIGMGAwAGmCYNCYDTGNtNANMG2A0m2DSY20NsYDY0DGNDG022NNDYmxA2k2CG0A2NjY2Ng2DGNg22MbabSGwdcCkqYm2cu0oEAHCJsJikiFstlGZkf82TsVftvJ7hrtO6s6+6pM1GY31wBCZh2Lg53I4zZ+6q75xgeDlTMtGOPG+MAQ8VHzEeFkFAPljTrzMzM1/CjFn77rc/1+D6cr/3z3HXlup2OHDzDdGq1WqhaqWmKrpxyvp5DL3GnwW+qoegvqq2s2+3c82ug9J5DQ0NVtJ/FtEpmcrBNBWJpCDAM8TZBmzqzf+Ohr06Oxqt2lcDgTZUqcvI+k8eKjRnHTeJprT6FxxvmE0G0maG6/kLNHNfoQbJm/30GX7xURy6JhPj8Zx48Wc1NlSZYt7s6Mr3sYg62vo5KDPEbmtwYru+SWPHdvXr7MMYHal8ca2D18Wa5s1PmTEpoUd7JkyQiDeQg5ZzIMlETeTJklu+zwOBrO0xnNJeg4lL5c2aXCl2YEkda3fP5BmeE1+X8fViLVnLiUceQ7kyo45hASTIgUEwQJNRuymGhBEBKVHjX85CRH+yaGIiDoHKNaKfj51G8KTXYgOZJ4Eufg0rmHAns/l1txpzd87YoSDGhsTY2MYDRBlESxIvtfeoSIHcA2k2BsMCNJsEObkxA1KF8yBfc1MzbSIZmpladk6ZW6ycG8PClSXmH+5HOO6maqqjI2zZgZN+GmJYht7wKOWDOKtsJD5gcUIjQWGHpR3gMkWQHBC/DehhBphpBXMQN8GKEdANANcNgNgPNDUDSDZDSDxQ9AOKG4DZDMDyA1w4gfjhzg+EHJD2A9gOUHLDMD1Q9UOsHvw9UPi7v8IH+EHyw9MP2w9APjh1Q4tHTQ9rfJCDf4pBigJMYDBpT/iy+f/+LuSKcKEg2pMetA=", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "5c717f1c5596474a9bfd80a26342ab77", + "uncompressed_size": 78584 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=16 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "4b69ab8a8634f8f194d84a88b044747f", + "uncompressed_size": 49080 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=16 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "02b8daab5dffd63fed3f6f2a1476e92e", + "uncompressed_size": 135968 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=16 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1dc20be8fec6bb6c6a00672beb6de51a", + "uncompressed_size": 119520 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f8c83713fa9e4410f0ad04e3bf7109e9", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "8ddc18f3876fe7d788ab11ae72383abb", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "fd5f56fb4c2e301659696d054ca7f1f8", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "593f6ef60996fbd698acbb9d1b754dfb", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "e6544c727698e8110dd4917cd5695bd6", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1c300a8b8f9ed0ac68a39019d9842038", + "uncompressed_size": 49072 + }, + { + "blob": "QlpoOTFBWSZTWZJNpQgAHi3//////////////////////////////////////3/ucuf/4Cobp4wbKHXcPeo2J3vO5yucPF528vPVtnbnfefPX0H2dKpK6bvYOiqdp3Lt2zTTL3dXd3O92bt5Q6fdt267fd3bRro1TgWs3Y6gKd2znnY1dkddxi3xt7e732+yg9l2Qnb32Hno9O91bU7A1NITTQEwQyZNMg0A0GRom00aaJjRpoJiNNMQaNMIwjJpJ+ptFT8ZCYBpKeMUT9KeniAjyaU9pNTZTeimmGEaTI09M1QaMmJpo9QNEIJiMgA0yDQBMTCYTQp6TaIxoTyqfqmn7VT8qemnhJpPUH6KZNP1T1NiMypk00ekAB+lBppp6gAeoAAaPUAANAAAGQANTQJoACMQIaaaaTZAU2hoaRsVP00EmZTE0wj0J6NE00PRGh5TQekaaYmjNTE00DTTQANBoDQNAyA0BpoDQBoGgDTQJEyJMCp+TRpingqP01NkaRP1HqgyekepoHpDR6jMoHlPUemKPSNAZDQAHpAAeo0ANAAGg2oA0ANAB6gGgGgACRFCAIEwAIDUxqYAmo8Jk0aPU0IxppNpHoTynpGgaZMIZPUPUMnqBtEaaNMmQDRoAAAAAAANAAAAGBVEkCmE0yaU9G1GyZT0YU8mmIJtTAU8maU9I/RMo8UbSeSAyHpNGhk0PUAbUaBo0GQDTQADQAAAAAAAAADQJ+ihbbApHntWLez7S/wHvMbG3kVNzwalgWiBGmW6VSjqOiT05NtkN2i9wvDgQ9kw1sVXborrdKytVQ2dEnXdhXx9LrnfKhovV3UsukG3UqB7rDrKIxuSrPjnYA4CeOyVKIjhoJPj1kBmSL4kKrg3MHKA+maYv3PSYdmGh1W/OHYhNMcpgdzc+S82FwdPmLSARPXtIXzea1efl3vP2AC7dp01V90VZIvmgQ+l6exm0iALU1SKLGbiSbGm3JpuPQLctJUtCP5vb7T39jqqUQzI7r6PglFL0D2bRpeNHlHh327kEHG6CEkFtiDHYuK0At6wgQlAll8oAvnJVA8hRC7kTLqsCZVn6My4ElKyEShEFEkhFWHvMaPt7kqtQiVoQpF8CrrXWtVXQXGuQlamWFDEmkhYZXmYuTbLQ530tcmyKUksquzkrWwXfkxaUukND2NcLXk5EM8Gp2rsjwL68QStrQtal2VSwUFtqVPkHUtTBJJJ8aqwhUkqc8JhqV1IfLwcxMhdToAHC5N3Y0ZV9gGiPzO7q8A+bv7isuWlqidLxsUnrrc4t62klf4OaH7aEfiaA5LHPlO5Jv8Hg4XVdXVu86OdfjciLepw8S/A4+ogRWTG2xofavv2CRmMChpIxq8p7iXqMq3G/Uekekm8zWiBuQWJ+uNBs/HhQAHymfPM4DiggvNLCDJvYrYteVqLSLEhB0cJIpYY+1gKWrbUMT0cVq0b2kjlq0DZw2XK0KhpHaNLqPj2Oyw6bxll2WeGaLy3akssnXuEVmto1wGUUQUMKHLFgMrNAxi2+bBeejxYkM5rHza0mxNs/WREiLbLrSsOGJsFu+i4iY5+hYhLGVgMVxwyIxpwjCiIEWIVDn4w4WMlvFSpJI5zpLho7EBsAejcAmLBg4wyCUYLCzgleW8a/FQYJFDqzpjV19DmJ45mFnkLozV0LK1y6LbnPkOwwEF4khRGzSAM0Rlb66Yx2ypHbHM0fycC8XTgE8VSfmZ93qQxvvtucuLBj06ZuDJrSlYlPQBzzlYIVI6MTXlDBLA83AsgnZVqmpRq3E3KCs41SaEVZZYnZYocPceX0pXsIjUxx18RSEICEIQAc5xoJJd8vgIw2mKL/mo7SB3WXXhDCnuNOrxbNy1Zu2nMgYVyql08aIYYVwwu9Py57tfYdddJ0nQHQDdDoNTqEupulZAcAnATgJ4F0pcMzURo5tI1wOICLfOSmDaYuBxQ/NjGpg9FlA8q6G5YsLOz+tabpDKcuXYiiKIoiOIRA4jWTgVVxFJxFJtCfaEFoT7Qbfr0BUrVkPJ1gckklSq35GhofzR+Tocrd5u85etr6WpzObzsfheZytTn9Do63K3unk73bavS3FT059Sk6lvWUyvLt7evrbfL6GVx+j0uh0+d1MTExC3JyK6kX+HH20cbcYI2qvc4W2wjseXoaW3RDHAW8Da4dNQ0E+iMRxhq9wkuwzwUaWberAqBERLHuIzRUcTMycHtSUjhY3BGMkWlKlllt2k1o3Sun6EB0B90j0J5KfoaODtVvwWXHDNa8p2jRmCt2JbvZsaxru7d1YVIHaj9B6BmvCcmBkNrU9k5i1dTdNhq8luQEUXUsSw5Zk5lgto7HWykrVH7HtEfLddHV0fPdVXGfCcNOvMrqxU0ovsK4N/yOv8pKoiOQqSLyBn52fYmMXgUxiVjvqnK5WOg7KMOP0mbIiC30BA0CWIHdoHoVCRqLNzMzd6CUt0bnR2lMaYwNiQORGE8KDvOxxqED9gjvhGkJVPLTWaUhgBbrQ1teuttCxIkdtGi+S2iWe5GPN1u618Cu8O7LATJ2GPYy2WrbXlNkqoVXqigopU6jhGAQ1q46YkhrVazWRQsngFRLW/GQ10AwcjZooJyynjnzTAxqmz2iAvS36BzGMaRkg13J2SeWmMo4Wp3itYvvcmKkFmUQV4DNKzjX6QZGGy6gWtCJoRjrCJroq1QVA8IsAh5U7k6mt9isW8NIIZ3qHSQPP4rvkeR3ZmG/Lx13X1++7EcYl+NP3ipuMkriInR9RtaMG7ALp6sM4IpERbEkxCQ4dg5d7GA6CIqAnYzMqkwzIzMyMwwWDlypC1qikCUVQFSLGiuUqs6lVEslMbTJhQocDIYOYCKoUuYhZamZJTlqExqvbAJko9JJJytES5mE7+EvnFC+6wGEuoVVQ4SorKFIVfUGtlcsWZQyrFzTimmHERDY/khdJlttu6KIbbbAeAsCjTzDfdkBxCcyVWQpv85uubiuqK3dytbCZbDDBsEtkSCe7rJU/wy3kbWOOuYNGDSUrUsa5aQSlVxGNBms3ko74Z3KhIIIX+ffFx+PlLuSnHxsdBHEvloWhaH+90n9SFrf2eghbaLoOExpMvdeo6zrHZ6hzyUSIjE4rCjn1r1rCk0qZzFVKLDQtcoGwtcR69MbobbDvFltuNuRudLWFYOhpcHORPSHfwmQV7UTlTo1MKVvh1sOMPlPI23ZfFDTJmiW0VarLFdnwhM2K92vYr6aU4qwhExVbHue77x7yrpChtjGMamlm2DbdrvB3o3/NbpBN1eLjvuD1Xw+O9Ywy6tmzVRbch9ZS9WYhakKw74Wwx0e9kQynVpyqdmuYnQQUn2KsfIwuvmrV5i7bDDb/MlIapB+aoGPYph5IE2XO+20Qi5sXCEjE6Gvgb2HzlSrkq2yxKV6a7sNuc8HrUNONhjzYlXqV1zFhWqvBlOZ+jrjz5Vqs5Q1h0otWSXDXsKlTI4yxnOLUqy2fPSfMgJTa15msQ6NHck1QiIjgfDI+K3HLVCIj53tBwagvKVahER9fsR9moK6rQRENhfi5sfkrCyqzER+yOz2oV1WuIjR4nQDqcjV23cOn1xv97xW354XqenvMzL4eIbbqDQyDgwyUN0NEdhLQTPuiME1gYpIg1QXdIxuypn+g27Qm2jdI8Dg0/I7ftFchjQAiJBWO4RV4tTC17jrzoFjiMhUoLIKGVmTMIbIZ5FgYzqxu1vnxZrYtuurTDg6yAMjtYSPNMFUwva0It3Iw2rbQd1fEWGtcxdzh4slTVxhg0R2uMgyJzrsOIoIy2bEw4iTWu2ODB2Hj8i91vHzLeFyLAmffL7IGPAPV8FVWAxosUsagW3S2r9ofgLumQAN23pt5F8xh0wSzaM9dBCPSd+4sn4FxqMXY6CCqTaQBGlY5Ss9CbLE16x32Z8GxtZI0Dqef5Pr3xr3WMM2vE2lscmFF9kKJGyXncJRpnXVUGfaqYz17d3Uv4TKC1nTet4VCVFKkSKbb7OowR60AlaVCaoENuYrN9usQVAUsJIF3FJrbWd3d3d3d3d3d3d6lFNwoF29rXYmERGI1LThAP337yoVvKOAKjDHUCv5sXzEgC1ZuINiEaSYjy7KeuZCOs4kzItoyJmZdVnlNsCnv0kkVoy1wvXVEURgSayluFeYQXZdAgOdgVOhYoDXdZ3Ry9/hAMA5UqYKKQSjlSEcqQ/DAVtksMzJLq7qApSZCEqmJjliqaqaJaN5zGxlKimoMfBpRnYzNNRiPRbzDBLqUuLU2pPkVWb3OjQYcol2Ws4pCmEB73ZaZKyx0ZfPSoLpQGq9VrLTdbY+raukFhhBd53s3SS2IeTYEi/AxyOCI+DFJzDFt3V1dKcR3nrjzAtpmsbZnvIBBEDhHlrZ0q8WDVZVq7VrEhrZGBhXLmBXSkzMzMy7zMzMzMzMzMzEzMzMRmXxGlqUhRJ6uYMVt9zZ3teGZi+iPlyRf7+12UZDyvtPW2zbWRdMsxAXLoZ7F3xvIDiVQqfcEcUxAw5rjWg5uvc2lKUA01muChoRXYoYjk/6F9eNxZpz99GQBWYfqYehsNqGdtow2N9HnJP1fV6v3mj9YZyRIddyfrLfe8/e5PX7noS4RHIbpbuWoxxmnbbKBQegJoTfmMZYwriMYemNueAhrYq1buenxVTnYq01VbkEJ5Z6zA6odqHxbDTTRDNzw4HnXXYRCManX8Lj0vy4JqDKAz+DhcSCDt+rwZU88ycJp9i5mOV4eW8dh+ul6ViPjm2YepK0f0foWz1ab2x0h4x8H9vT67B4YnEze4lQymw2I36rhzrMhpoU1SK6BZSEhaNhvwIwT3bQq1ZMAw7UFt8j+npd9ij/tQf89L9i1fR0bJjwpdtTQKxc2bNmzVm0k/v/h4v4/y+9OTRZ23t21fXqrnvnVOOBG4ZUtoxVhgYsWkvoiO/2RgY4ZgAfMRNL16qk3jHIYBNOGyVAy9FQIBitSXWDfCvMG6vW0l69s3WBX12zuYki72Ue42ce7u5Mmis5FtR3NzIuo78bTFo6elPrkPwm8v30D/SsyvnSHwZQrIEODoVTCqqt5Urqqy2Pvh7ZBCVHqNuHs+KVg3TAjPDCYBKIl7s3sWkAHH3P6V7x4vChb69SYjxfLHTRxlHGGDjtgzvG1AeNvFm/UZOzZkSsBSFXqdmPXP1rJAtF8tNQjOrDwdLio5MmweRJpxcf40b40z0qzosCUEejP9g9aEIQpB0MWIqIAGWRWrkVmFDQMRAwEvELJgska0kl2cdSpJsd2v8rrpOtvdhHlI9VJdVOu9UXf+zWprnq0sjWSayBXJ7rTgPsyoUhzcW1o75aU+e4ga/YWtKBi0QJJkzNnL/EqfoUaOl1wFAc0w1JmL2N39RjEevHrbsLb4vRJTXXRYfQLJ/UXmZytxC6poO5iqpVniijLBs5LW+FSHmWUawhUUwgR73nQYP9y4oVcfsscOCOA0hHIHIBnY6FzeP6N9zWUYkGZtZK0KUE7FJpJrrzkeNmQ4eFgiwWNFxcmFkIDcfl1P2TTRLaMICIg2BaIZlnedDw+/eaGc4MxFYkYCOYSVIlJjChOwUhFwes4Li7SQ+YQuY8M45mZ4EGYFTiD939EawizIZEaOhVa8EnRRtXRTYF1m3WKFymbZCAYKeDlGmMF25Wylqf4SXJVQEWHf0KvUvW+9bTjvilB0WBCDpSkhpjOxmptG9Gy0JY48WpEGjYjpxNXSmVNjl4EBplws8S4/neAwdrIciGa2WVWw8YLXhsJYgpYoU1atJ+MyU14CPSkdO7iEqpdk4YWzCZ8pVwrkTd0HsOq2Jt80XJy4WG9wKbEMLuBDQroOMFFqw+KBEelEEtuFIt26k76obcKOZbkXPA8gRZQlHpgjFqHsu6BlYIxg3IUwqaauwYFOruVKcrVqd8QWto0rag38FNtgmUHcZd3InvW8e+8mtdPYakfS3s8NKQRGSHDx5JlHjUMCFmSMEWDwMvm80tE5YzBLlTvB8niUZBGMVCFN+Lu5VuazlszlOJo6leIdJ1FomUGoXZqlBxqOohbXmRnYmg6zGNjfsGFMtZt5rX5i88XK9pnDorldmluqmruSth4vWhPVkL8osyzEDbbHRfM3eg0g5CFEREBtrO5oWvwNqaTlcQ8VkYQqpHldG7u7u7jWHLOGGS2BU+IjCZb2qNtT1kqjSZay/McYwwKd3BuZkipLxVlbVdmYtQNJjZDbwUS5gIjJCJSDxizjE6lXYYK6gI48aQkUBwfzKovic5fuu0DqmVVCBuQa9e4v63RkjeK+cgObMqw8FQMILl1Vm7E1C7N32Vuy4phUaMcbguR3lBKU9Xfvie4Kp4TX9X+NNlv5G3xrPFLMqz6CVmbqJLIv3mIwMo2hjQwyvkQOm/BTKZNTThGIQbKAg2R+ASrWkC+XdB9xIeKvrOcwQ2EsOE4AK5Lcv36s4x9JSmb9fGmBtGGBFaBFemyyqW6iW+84tLWhoJwUWojDcpuVwMLmY18IAPtuyH4bNSMGjnDdjN7AFSvcYvfXNZ1ICgGq9BmKNAo3mKyayym0pnT19o69eQTAqtq8m+K2xgeeZG+63n5lYMh+iAudqCbBkUxVWI0Itvg2eXGHjOaaUzybdeZUPmFcIB6OtPceyUQbaOwhwSEIMBnYFj0ti5cM5cm81W2A4kMIr1nYW4gEignrqvZtKz8h+KVYZQxZCMgYso4G8SscN6d8xoV6ImOITZxtbZYbZpKCOZxRpzQdkcb1mDv7MOy86E4kAPxzkGZGDvxjSyZSQkrcA3FmgGBOCCJBkQF3fBs6Igs5d5wVeCduO6xTjRHcBqeTddrGJrgrNCjEMCDUoF8wQlA8ETiq9EgDWdbTkxDQ1mA1LkCEHOcjGsDOI1xZrjmxVO87EHQJMRuqp4ERGaoQygZSqHVaizmCIAGCQe4yBBGAqhL2Tqc5bl77f23bwXIYZY0czsqQb+/zQXTa5st0irduqSSKt8m5DC5O5YZwTAxjoFjDOevMyo1T02r0k0uuxl8NwMbrxAZnthGYWFEBvsCQYDIQgzAik2a/HFwb36XgbkTY9lMtBu2di1aZZCYbPjLYupxNJUxcaZuGgbL6CEAXMGYCEAIDGODK9pxbB6DRfS8ZyGZHn7XAtb6xy8W8RO/1sb0AYSihF8PBiBl3KbeK0/O0lMNM8m1Ma5viNJyuXnJD6pSQgnNlqqNJqH3sIof17K0iQKpjEYUNApeHpF2/67TM8yKIo7iiMjMEGtOm/2r60GgytFunnYmnN4EUGTtAt+/SMJooIJTmrGTD0iVlLyoNAAuiTiUngMQAUR78t+/kYMWSobVJcx39i3SlNaZtBJO1jIQJQ1bcUI9q8lk77SEkYAkndDag/n++RIwfVwSjM4EGgzL8/ymdvkQazyWLSlK8JNCVkn/A0eHQtrfJVeTgv659ms7FM6A8joK+6ET9Kmj2nzDAOhOYCRbSoERlKzDriG8YoWlhVEkqVQjevz3kdHdZQ/TeGYXLs28FdTjptL+IuwC526iXw9uhI0DoYG6tvFck8L0qMpegJFhAMjAQYG7MAMFBmViXy68U+Ghjo0NNGlGks3gN69vwojx3+BurwVyFr6dTcykp8Rzkd0wI5TELacPYzQLyG12A61OpIJowMxOQgzYaSJ5xAAVxIr4UCwRiuZB7f+cpCFaPJeQ+EqsRQy/g/HaZOkFgvjRCikHGOfsL618Hkb3bgWqsoZ1oBnHMxzwhJscu/yoURDMR+s57+I7yM6oB9axUBYLYmeUZiiZWfttpzOfI1MEPuLmmQJArU4O2q1NqMemZtpbQZr8hwQUBTRrUMK6ZhIHtgBHdoFQCDMdafqm2k0qd9M/Zxx8PL4baYstPgb9daixaT6LL1lftLLys8UL7Xp3kH2koU0sB/Oy0u4wkK5c0vfrm92iqCbMK5bxFYk6lwjxAPqahcXaY1fpn+VMtKNlwsnDjtHx/wdRwfx+P/KXFtub13scToO+7/mcnb07ADD2WPmBMhHvM3X10qblGFGjo8/yiU565ypfUSuzVTmTgWUl+hfT4vgOHHXSL68cIc70qtNMzxsoBQOrxQKBHApVyLpGuy7ay42qn1fT8u+n8BqagVd06D9P6uTAk87DaXZ9uri//d/GOEI/r0vC88On3m94o3+S3wjin7iUZmFdLd5ubK/1xmKOzqbrELSoGCMdh4OPgDQQrrnOaoOMLIMNxn8HGzKSgnsDJyKBhkoUSjIhNGIKmpHIil8hJChyhuw0lVPnEisSTAnyByMT5eLJdndMogUZwwAB/pqavTipE9Zq1H4fTbGrZYtzpulyN1hyeCuJwYjY2tOKca18u51Bg0JgMrKpZkCsVKqaZAeyoZPF4wzoGklmPnOGv9lDY08SdnkeKogwQAZECmAAibpLiHe9FcMO93BhVii/CTcw+okNmKol0qGyFqK7GY4MSErTkqcICvOV2xwuJRdQ22JiOwrgJRrdcbr8ns7wzcAbdyjRvRqzDUs2FS0t8jGQodqgyH3UAyCURw3SxrT8ZhbPsJZP2ZhWC8xi0YrON2k1P0dT1xQA00gEUUBAQYJiDEB7s5k0TmY+4kCjhGJfcOjH16LTuankkEJ05DiHkgkmQymSpyNXRjGTFMw4rm3AvsPYK/5u4i8bTBsXnfVdsvT+mMO1fawgmvDOYhB2Cul0zTOYc5hqg82q1a1WKyVz8RkxuAoc3UYM0YrGSTGrL7bXL71q1dyPTgy4gE2kzCEmLZ2zCiW91qiSowNjnRdcHcz4MrimVideUeDhbeUfMjJkoDnnEDkgECqjojW6Ps/L7TIUQ4/l1gAWhg9BzmrqSz5iFfQdCct6QwlTFTSb8aUePHB34DVFbUHNnDV8FXNzLJBnnpDuh/zxujQNSyvhewGOJodO0AJBC0fMFeu6myrw/NuNnMytWvmjudyMAfELSIrTeT0qAiQI6IR/KP1mN4aQzoBQvwXiiH3H63em0fxVP3fa05QC/UaAw+Zh+tQ6YMCSJYTz1sPB3iwGCZLMD6WAwreummMy4x9KNcWeNsMAsWJdrFOlTRkCIISg+v/lsxXxQg/TGKx7+ge4uGlUAQ9hGMVUYfa/TiGRs7UHRrwO2Gkpt/mSCYDOzA/nHdDeU7qR6EwsQJi+D6AB3oVLJY8chXa3ZpKxyJSFZAZ2YGHqXoczirQH7sJFNYgd4q2WQdYcHQsE6L/N3wu5nTVfMGlybgAxkb8abvPwhkiefIxNt2skDKKwsMSja/q4F2pYVAFyqboAHIAywNFlb3jUFCibA7Mc02KtLj9jtd7aIgvL/O63TYWq5eruE9DTWoDsggiyOIWXR5wf6feWPviiAsVipVgwE6S6/pi53PSDr3Vwn87QL21FRCcHJzb5DB+jhoeP3Pnyc/5vywW86G3cDlu3HF2vTvIPe2B3uN3fTdBbbzWw6PS0hXncEpMwkSLrLVENsMEoEjX07ALVZuiDagk1qQamqF2/Ree6/oXY6SmzcibzpSm2F5MDkZoCIxGsWFrYYq68uyYvLwMg3ClxmXNLwbyaDsXSSjF46AXDFI5HVAtd1foGyAQ8VD5w8IDmjSawrromVk9wKQzcCJSlOj7xVMJM5WWo1rEiIhgNdbWdsmE+z3e5tsz6LW1tbW1tVre/e61g8dvISgo3jarDHHFLJQoSFC1WrppLBTVhpqYVeIF7yt3P7VVW2TAjHyBGJve5fss21p6+qTv80BZL3j7djJTKWgCmBKUJerdxRqDRA64OraPzzoGjRPFAUlkiaF+axZFB6hErIam20kpGYgDn7fiOa6uw8NDZRKOJRpcr8f4uR+r8/51vn5W9qUMITzqGAHghiHNgMwptahUtYWYmliOLfbT8tzYWbmcRLOzNnr6+z69oum5XGsXIPHF0Z/k3t7e1De3nTRCBuk8shI3kuDdHZAHyEWmPC4X+tHEir9n7lmDy2YI+QuXOMzfsYMiqXTgpHVlcc0jdj4erzoojx01Lq6uu04edX+PZm0fZ3W3NdvGgO6yQ6MSN5GWcswmym2zXfegw7N1t3mdT5LlBQy6HRzHJra8AKn5iKqfPn3npQMOAwj+ZbP7TEABX8/SAqEZ7GQ5REmn07laqsJmnAQskpt8L8JLZBwBceOdaP87dPx0CqeiObsJeT7f0ga8qLCp97oSsSKDgiORwQwrgRX9h6KpyHIIiIc6HSzcKFccFXsodBpz9vPjZkSke8qVernECWJZumVAGWM+slwD0Ksx3Y6Cufl1DzDo/Rfvfk+v2vS8l/ZQN3UBwRERm5CpupmWkmQy3Fkc5EdGKoYBZgPADmJjjbDOwKy+VAF9E+LwtXIKjYZzcvLclw35Jd26yIpSzSCyFA9/S6BKzuWAmQLeLAnOKDbnmLmRSuvf0QbAxNA7roTVBByUpVltFgUIEwBCNKCzvqMYL5pPXssydxWKuea0MZvaJqPL+0o1NqlSOXZI0glyH8jOyTpUARIVaIQlDwMk6T9BoVIDa9DgItKdTF0K90/zBIk2NDXzj7eP8+t+xZznL3Kv3Rrgq3x30K951bqTdMeT86i/fkbXO0U0IQs8DIDk2tqzzRYtbJRhYQYEU42P65rxgAMTQzINw3p4LOhQt8JAShhbA8+R2iEa3ejiofT/Hk8PqkRPkRTu4W/HGyOjRHVo4zxsP/FyqqSC3/ITMOfbGTJkqwxdy0Xtq7yAu8+ltm8oriDBFO8q107YsGd4158+7QAiAIANWBEk6DQpm2qw+r5FD1hVSDvywt7qampqagdxoAfOifJQErNy7uuAA9AmwJgYmh3nJ306nVbW7avSTyr3AIOuNC44mO2bN0loaAs6G0uNjZz81fHBLsuDNw9Xf1iIcgkiG1KG8EiShQoJHlyo3JllgRl2SyWSTRFRaJKxaPBlYrCuWChQSVFgrFQkrFRUSVChYKFChJQoSVyJJLBXKEloRYK5dGdlTaLxftVXvmyvLeloXXKusjDS0Ud/F1Z+WEm/8FNAAAEFwlVMhQSw3x/6EFE5ta5IhviunsXuLibzdLPYy9GdPYu5u35b2PxoMbi074VMDmmANQEh4ZwEDKA5kZa+BbVJhAgQW0E9XL/WhYHDcXAApB1c22yqRmfXCbg0wTv3e+ARRKYZFa62Wtv83F1eVfV69WZnixn8YpTV2cvvepDQJIcE8NQhnkio4Pvhs1rxTzClo19nUXzGlS+0mZuoazScw4dfmdyZI9XaAIhJvjoW9eLZ5JlaLnNPuAz5MKYDgRySfcyuHxZSBTWv6oG611v6UI0IwOIBUsvYl0AskbjJ9uAxyDzbWC7be3WBAyYTwOXd6bn+erbvgcbFv+iNP01Z3RFgi9IkiKEkiSIxyQqEiKiooCokkkkkiKiSKFCgwdze9Vrce/ZGfdb3RZWha4PScLe72I42qxFrEqcY1GSlrVQjrA0DuXvWC+GHXap8BW6b9G4+37nt+H5JHvePx+3IA5sh4gBA4RmmaI2IwBQSKjZlcrnKOEWnlObzeb2vS5qSSSSSU7rdzp/Y+zvOt3On5PS9LY8Poooooot9tUgQCsSLmbR5C72ZF3PD46G2fnosH1UGeic+5OfdRqXlA1sJOJvsAGODMcowhXYwjDdmGMydAW18BYTolR4IV6gcsiWYjh33sfB+z9vy/k4NyBxOZQgB0BwocOHDh0sKt3NfSUy1atWrVfEjRo0aNPgUJNNQAN/T7doZvmG06tGraIquwXnFtS7heaWRmgy2seTkEwshFi6DIwUMIs0iZXpy9YiBeTSmrZeaVNYxbhhz4/ZHSldbH1cdhxWyKJtMDbOxRzzXfI6M5zetmCYPDmmRiFC9O9JjP37OgQa6naSgXrJlP9+l8teenNgBxh6nJAAB5UDVqaKqeqq85MFAAA1kgDAOckr6nVVGjx73sy3DIMwydFpub29NZifIwcHDyPIazufP7bCVb/GhhrCrrfsIXIBTw83XpKa4EKWFLwIYrq0gS9nS4szO2oGoufQHRQIkRrPLDz8/EtzDDdRDWNbNGtoMRjku39iIsVzszqXbd5bydpzIKya0x374YrGqZ5Zid7dK4xj1jj57AczqhyzRkklDw5McLXS4EISxgsJuk1lcrx8rC9zGyc7gRSjclMU4uNjb78e4LIyPYWxmFZ6bhtNW7YE0dmeaStBppLSbzEBKyWKLQvKUx/fZSLQAABXFsnncbYysnQjgbgA5wOGryp3zIOXNEJGMtKCBAujUqtUwL7LsHiDxLCRYMyLtSZR6u731vr5U2ANnz5+G6tHKRz7l3o3AULbtPcqQ7mt7CcnrHnbG3S2/xHoh6EAvtpcZW1xMdlaTTnIJJJkmHbTQzuGtpLmg24NQW5EeMO0MU5JVbki2Ww3W5yXRGwdT296ePO0OAg4aaTPUnrQ6wRYO9xAgVexEIPfLoxFoQxE1Itg64iVbXZFfqbERNkmLaV0jOEVqVUHkwH9Q5pcCzqJSnIRLStI7mmUz3Xawab19rw7PXZ397CtLdkv2ZVLIOBnQ5qdjFq403J0t37XfjJY0ONu9Ng8Oxdx0KsxojHKREqnMZGqjXSjb56FIi/cSfPS+T+CbUNjGOFF3pLjsVjSaOydeM676BsMuWo2Gz6vudvx58TqXTMzh3PDDnDBREl5YpCLXhOr5Omt44n7M+jg7HPtct0OryjW5eip62kkMghKypEXRG1DGFrNEcnqRfIbA0qNpwEM/nW4mpOmnGWbjFxt3ltd1m86xjxbr9j5F+07L0ytUaUy5SpS2CVtLRhlCUpX4jbXdPG7siNUGjKpbICWeeq5SpoL36q+F7lABYEGqMGJ7zHwxeAkgYQOx2ZuGzYL1C0jYod46HVFyynJwOwVy94a5uDaRzvGLlHSNZEXZimUTDjncQ1kmRGnqi2uorlY6g0sRfryEMLTtWqYTAILulUhF51XZTtC2zp5vLr9j1BnQNucBSIFUIFAQLSRdEDWsQKnw+3hRnVt7k4SaPhlGZljgHUiHM9Dyu19AGrt8WNkO6aYKeulygOCqwXGRl8UiqALcrHhM02gKvor5nnx2qCeU4PF9NtuHVvdcCrTx6GVtYXHzZWFwlfBx2DQNCfkqtGzS+T1dHT012qGCEvPOZxgdDh89bJFYXsJWH4ZeT74vNpm4WghG5Xw9G3x8QIWwQ4A/VrZvPiW2a9DA+N8DXnDSPbMLuVnaLknnvn8zseCJ8+AgVlgkqWCMSNpvt9uo4nUIZPiIiUKM/qc53838GtMRCzvbvgVa63EkoSuC5ty+6dDLyULC0OI0URGA/pytrtNev57LcZbd2cDbddy3JznTttYitF5x3HZN50t8Z0oxEKRq5jU+CqQrCB4sUcaj9PPUT28j3G1l9PZAp0UpLZBlOnC8qaCHYBFtAh47NDncgUWMAD3oZAe2+00CFsEXodd85IdFNgins/me4qdzved3uaQ7YxN4KVsEIK0iSCEIC0ICSFmmCE35cBgEytX2HZU6NN8jTGuqaPFxG4w61cYZIqvIrRUiTK05e0VylY0pEpFFSwpZuYpEWYpJVjd2ALI6yaqcXle7m5pWADE4Gry/W/TwfJTDtSlKNR6RSaTDtSlKNSlKUpRniXiaB1h5mgV5eJpSlKUpSgdYeZpNJpSlKBYo8TShWjxNKRSkUmkPDxM0mlJpNKdD8wdXkZHV4ufqBEGzw0cI56KmOiMyvoay+iIZkWlrtxZRXUMjgGGak1mnt9AlZC0W6Nl0zTzuRndDe3fOPvNwo12z3AGw2R/b8uwMojjZCWPzstAQwYQgHz0MJwDQlDznNiv4tYYOBi97mYMtgUzGKAxILKmegMcLsbMaCE4Ak53pS/qisZrtXPGviNvDrcLpCUbI0x23ALSRhYCgKI50h9z3y4GHle6vaJ/S9+Ot7loCNifBCAijEUhfCNwGEhYhklaMfcAyqRDCQaDlbCXXMyom1VFNxn6GTdHmKrCPChQpzDu83dtViSycgBgF1gK0YJuDihRio2xVPHFCpCATzYDtR4CEAgYLAFMoEMhocuPW0LfE5MVfs6NJl5eWYgloBHehlIV7sg5SpKoSubHr8nbebZbaMlBMSAqQQOno6VX0lrkK8sKtWMoijV4+OtYWiuU4y+CiizRxyliDG5F6WPq5uqaS1B1GjbNHxYnr1AYDNQmWvUWFKNiVZqsXoRXjBmUgctXbsC0EQt2cjTb23NfC4/2PC6yG9cptyi9Wx60gk9dJJJJJJz8uFJJeKYDOYmKC4v2nx/F8Wt3/vtGfIE1ADKpZ0TS1rLX5MfweDwNRRssHcGrqmlHVwPD8n3gMnJyBpVnXdLb1zaPh+J33ieJ4eJrx60daW8NhevboGq1Rp23WO1t28888DPW6+t2O13WZC9DAcJeMJQ67VdIXnRV3j70Ui8vLy8vLGdTwmB2rOqvuhYMO4zt44N5Udc5R+rVt7nEMH3t6QkaUYW0uwyofYxMrAyZpb4U3vSiz4EhrZ5C5mQYbN6t5t7fRJYGhq13jV6lXln1UV3thNJYXuNnuEB9T68SJEOIyl2a9UvyLUqNNttWe6v2vRgwVU9k5ZcqxQsKyzo8+is3EQuAh2oTAHY6iplhAjhsEVbtcnc7no97zd+Y5f9rc10yewpimVA4RFPVh3jnKt63U61JsCQAYNnpqcGG6P2HWYmo1FFj1YzgFwFHzwYUo4Bsl9y2c7tsyDpPc0wb3ziXcts40qRCpBhKVQt879+bSIiZpUXjFFzBQvClevpRd827Qtd/I9Bt5b7FuZ6nuH/Zl7aYJk2IlHIJpsFwhpgxsTOje90+DyVBawsLU8Dod95Lh3dDPEvdhUQ7urqHCGAkiEwsXHMsOdYwWe/ky+My17y1eZ9bOX0QVdDLXS1bIxq+mpJ+doKyNBa2NVumM69nsRKM9c6HnUnXi62f9mi1qijKc16glsHoO7Xgu6OkTCRw3k5fu8/U7RVbIdT5iTXh45g2dWCYoaISKe+1FBuN/eZPA6k4XHxXuuLoPSvj3w4VLOsYFetTFRe2IKjZYUvuFh2CgFuWMY/Zwkt687w9wzuuj6enjVb6FpM+11h25Tr6DmRncDD8cm/2F2iQZtGltmkVNGza5jYgFmW8vTZVGtzdEDoHkipB+ESBN/RdCpUFQWdTm7KgNM/OMMGlG4d2f1Va1Vl7TYjRkqiq43GzkheURM30Sa8vLNx1ZstkyZMmTEABfTWtgyMEWT47Me2s/+oCmK8E2/6rJ5xhjcZowPAcwKMhdOk2GrtJD/mIxhBFEcDVfgY8wHOBTTOdxCK1Yh/FFzKaabGxsD/SPAPAY4N3A6wChEQRBd2dCzB0YMCWRXZndmgAXwF27bbrtLnis3f3nC13beOtlvtul/XUgb+W+Tb8TXVVJlWUoZVKCXDE3MxLXLuJIIZtpCEMbGm2xtNt0jVDUtshwOlyyWN00xKgcJjYctEMJggQ2BDIG2mTBCaamJcqYUO4yZcIocOWmyYgbSho8SyGGE1DSbFoRqGhQjlMAZmuGv+P7klnCosu7tN/20/9JmbLflvyQwjryqCxSxCsC3hOCDgnhUJaTKXAuGrZ93d4nLunTqNGO86sYermz9BiebjLQJRgvlgIx2K9enguQmdPTSnxjZ/SkhDcIGUGM5P06/AFHZfFu+DkPwg3s4wcDaAiBAtkcTRA5EiVFEQNQ8iUiU9Qvg3PrqbTP4n3Vntul6uW8AAH0e7fZ/7fFgZtVrl7hcqYkyAGOg1ZmH5uWZ92dPmVt8lMvqfEue/QJ+hwzGaO2rhzdBUbGNKgLJEZew0a3qpsFv4JIwhgmOAzZvDC0k2SNwK73sJ5teMzaToMOzbbZY6TS+A0HTHx+q7E8MDL9Lc2lorr6K65I7Q068bvTmPEn6Hodveqjau9717e0kpvzjfPeqo3nPhumJkFX/eL7st/fPG8n5vwgmHrtFUxMRLQ9m5Dka/9TKUvnddeTBvStLTvdtsn7nxrVqPOjHUcjECbEP3/f9jn+UUOP8aHGC0FAUEPdSFGxpAOwGKhq5cuXKAqVm0DtUCSVCJTMph3y7u6YCbr6gjcYe0wMbP23W+4zvXdxyca24mC0qTzoKMABM3N42N2UAJi0CbG4HASuv/NOskc21AE+bHFsAAjbcTRL29+DZi6+J9XqqwBb29vZzNFYAFiTc3KWy7D4Fiis8x+YD348cOSvz+WoV2ZrRDNA7Rg35wKMxJBYCGljY2NyERADZEQREEQQA2CSDjgSJERKIiRESRCJERJEJEkITAAYCtI5kGLAv+OtLs1SNyRA7yCERETRSik0mnjwXlq13dVju7LDrbrtQev59KgKKUC9kHv5DkW3M0vI6jmczSMfHwuLo9T+fBube3vdxxcaHlEzIERAcQAgcwIxwRAhHZjRbu1i9ZX68/LdbT6fs3Ef8eaqtfPaNRzv3AD3OgWudPPdPO8boxr2MyYpQ3HbeDFD6gE2rsABY/+67s1qe862IohVRBDP79/yiAwRLu73R1495Y7l/1sGZj1+6Leq9REXFZq5fH6S7ZqaVjQxdOadmoEqVgA0NRFMLwfCF3JFOFCQkk2lCA=", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "eefc7299fceddbabedc52ae8ff757212", + "uncompressed_size": 32224 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "c0df9945ac6194b68be739a3b07cc65e", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "bc154ba393ded5edc995dac1b4b5a7c0", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "b15584b2f35edb33be8f345068b26269", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "30536261c248626e3c8593f8135f8f6e", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "676ed3b4a7b43eea908136605de89448", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "394bbd1eb532b2015c90cd5c93b84fce", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "810daa314a8028d3063282fd8cbcfaa1", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f64e913d722118df87869b486c81e1f8", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "84964f9b35beffbcc7c4982fe4e3c373", + "uncompressed_size": 32224 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1fc7625b60dbe46d21949dec1c23b6f7", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1efda2582a0d2ecce7eed201f5a7a85d", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "3cd01bfddf8a2febed11126c12a0031c", + "uncompressed_size": 24000 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f19b19c70c7df67e781a5f96753e4526", + "uncompressed_size": 44512 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "168b32be3ffcd94e9455a5f0666bde89", + "uncompressed_size": 44520 + } + ], + "perf_compiled": true, + "solver_id": "ConvHipImplicitGemmV4R1Fwd" + } + ], + "network_config": "128x28x28x3x3x128x28x28x32xNCHWxBF16x1x1x1x1x1x1x1xF" + } +] diff --git a/src/tests/fin_output_perf_compile.json b/src/tests/fin_output_perf_compile.json new file mode 100644 index 0000000000..e5c57ee299 --- /dev/null +++ b/src/tests/fin_output_perf_compile.json @@ -0,0 +1,320 @@ +[ + { + "process_env": [ + "LS_COLORS=rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=00:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.xz=01;31:*.zst=01;31:*.tzst=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.alz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.cab=01;31:*.wim=01;31:*.swm=01;31:*.dwm=01;31:*.esd=01;31:*.jpg=01;35:*.jpeg=01;35:*.mjpg=01;35:*.mjpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.m4a=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.oga=00;36:*.opus=00;36:*.spx=00;36:*.xspf=00;36:", + "LD_LIBRARY_PATH=/opt/rocm/lib:", + "LESSCLOSE=/usr/bin/lesspipe %s %s", + "HOSTNAME=cerb-rtg", + "OLDPWD=/root/dFin/_hip", + "UBSAN_OPTIONS=print_stacktrace=1", + "TUNA_DB_NAME=tuna_scales", + "TUNA_ROCM_VERSION=osdb-8348", + "PWD=/root/dFin/src/tests", + "HOME=/root", + "TUNA_LOGLEVEL=INFO", + "TUNA_DB_USER_NAME=root", + "TERM=xterm", + "SHLVL=1", + "TUNA_DB_USER_PASSWORD=root1234", + "MIOPEN_LOG_LEVEL=6", + "PATH=/opt/rocm/miopen/bin:/opt/rocm/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "TUNA_DB_HOSTNAME=localhost", + "LESSOPEN=| /usr/bin/lesspipe %s", + "_=/opt/rocm/bin/fin" + ] + }, + { + "arch": "gfx906", + "config_tuna_id": null, + "db_key": "128-28-28-3x3-128-28-28-32-1x1-1x1-1x1-0-NCHW-BF16-F", + "direction": 1, + "input": { + "arch": "gfx906", + "config": { + "activMode": -1, + "batchsize": 32, + "cmd": "convbfp16", + "conv_mode": "conv", + "conv_stride_d": 1, + "conv_stride_h": 1, + "conv_stride_w": 1, + "dilation_d": 1, + "dilation_h": 1, + "dilation_w": 1, + "fil_d": 1, + "fil_h": 3, + "fil_w": 3, + "fusion_mode": -1, + "group_count": 1, + "in_channels": 128, + "in_d": 1, + "in_h": 28, + "in_w": 28, + "out_channels": 128, + "pad_d": 0, + "pad_h": 1, + "pad_mode": "default", + "pad_w": 1, + "recur": 0, + "sources": [ + "issue_1760" + ], + "spatial_dim": 2, + "tags": [ + "resnet50" + ], + "trans_output_pad_d": 0 + }, + "config_tuna_id": null, + "direction": 1, + "label": "resnet_tuning", + "num_cu": 60, + "steps": [ + "miopen_perf_compile" + ], + "tag": "resnet50" + }, + "is_winograd_only": false, + "miopen_perf_compile_result": [ + { + "algorithm": "miopenConvolutionFwdAlgoImplicitGEMM", + "kernel_objects": [ + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=64 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=16 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=3136 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=16 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f8ffbb181ddb59614f385a4d73403e5c", + "uncompressed_size": 25240 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=64 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=16 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "cad4bf973c5625393b6eecd6b9893f88", + "uncompressed_size": 54040 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=64 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "048a2918c11084f40ebe8154a909fc8e", + "uncompressed_size": 54040 + }, + { + "blob": "QlpoOTFBWSZTWU3tpRMAH5F////////////////////////////////////////+4uPv4CvuX3w4dvp0PfePTfGL2993m6pvrnwTXlO+593uu3XHze9d6Pd5n2q7Ed9muDbVy9pNvd7wt5932Hfc991vXVfHrvPXvbdeu7Zr1dtu3GnDtTtubIJwHZWhQHbFDu99vV9HRdzymX23OPsdu+ge9fBy7594HkDRImIJpiaYp6ZGmiaaMTJjQJpgAm1ND1MEYEPQJowmEyaaBMp7RJ6aDT0mhhT0mamaJ4p6noTG1TaCemkzRDNTaGSehqGmjQDQNEhNANTDUwMmptAJgBTwmgCj0ZpATUemTKZkGKeUeJHpBiBsTSM0aGpkaZNNNAaaDR6mIaAPUaANNAAAGhpoNA0SZADQJpiBMmIMiMMiExMJpoE9Jo00MQ2ifqnpGmTTRiAyA0aZAaANDTJpiDQAaB6QDQAaDQGgAAADQJoRNCNDJommBMqN6Gaqe000KaPFPTJM1HogPKDTJoHlA9Q9T9U08moAyep6gaHqDaj1NDTQep6hoGQABoBoAAAAAACRERARoCZNJmIjAAqfip+mmT1U9qn6myo9TzU2mqfqbKT8IaUfqTan6UaPSem0po0B6j9SbTSbU8p+qbUe1T1PUPU9IGgHqD0QBoAADQNABkBoJJIIABMQ0CemjRTxPRiGpT8RlM0NAJminhoJpo0aZNU3qn6KP0p+pNlM2p6U8yJP1NTTTEP1NI0aaNqaHqPSDIZAA9QDQA9QA0GgJ9VJResFyWHsvHc1mlt/dmPNdZmNlWOa303ldDf52DHS+x9OFxaD2pGUljIykGLY8vO4OZ5eHHOigw+m2rggQ4rRKJ1jWp6+wE4h3GvgXhOklBgnIsc9dFoQqsWCraRia1CtLSR74ihuu8VwvCsCSpWVTwGvjCoSQ7jEnC/SihipyyMUTOFS2MuVfYpDAFmZ4JmYDz+bd/JOHD5q9huJtOpfOHXw6PxpEUgl5HQ+u+DDazhB9NkbnkX+LN6EZJKVTb1yOnYkQ0CMXzXi3dxUQBlzZIou7jOke0rfoeyfXoLUYkqtCP9n1P4LZBvlP0/1vlE1eThhLX+P5smXj82UkvN5cCSDOaPLYgRcaLg0xixpqUKGNWS9NBuyypNkKAowFRnhsCjFVpRWlXZjlKUdlruoBmJA5MjQEmaUtujwhEGJyRHORwEXUcOCRZKGSClA1EJOw8mcHET0UYzJEBoUGo4UHasYODqElJGOmhVM+AzQlAPCETMLQk0PMRFRUMzro2uZPPskGRUdERDMzM1JAjIqoakFMz7i8pbbQAsLtrScsl6Kd1TvUryuXXlXqM83NgiCxTcIz94z1WFGSGFS8FOMckQJ1J6IDvJkPkYAcAMe7wXvsbvfbZ/Ktu7nWX+y5OMl19bAi4mNtjQz7foUEQIUQoIBRgERHukdj0aV5dfDJDy79UGHFPPGCu/pQQ2cWGUr7vM9C4Qs9owMXuHgZ22qLZR2UiNnKjRhJFWkGhqQFRha2yGD09dJazvmS26vTcVijPGBkQ9cZDVfLLoWAmbHsKEzDj85AW6MCNSBIoAq3rIWhqnvWrWptUUdGKWk2gbVjNi0bA0cuUGP2bUWNbwO3aPumiBikRfYN4GQ0QxWOHLCWe+6+Zo+dH23cledcRV47RosvsNq268aOZ89x4idrPhVia090RHzb6URy7lpbbN0WEZ4ADGAMYKI0XDGym+b0YcPCxGXn3g7Apjkt4xHTO2ucxK3uIOOkzs7Ri75RzrPTrVmgmuhU00gkNZIKUigxHl9dAZIBOaaLMqCkWxMhW1UFAYBGZQev1CJAgP2xGGSjEauSj4HCVAKm7NNyGu/BBRu9uR5ovnd4Y5V0prLKUz0AcetUGDTU8IuVlAblW/cVYozs6yJhXsnAh8wLV84M5JjBzDOeNCivMLFevPWqmkv8Lm+R31OYR4MJSy3s3AVTNVVVIwZoDRDOO3gdztUplGJ/8SzTWwwOzvZudfFddYaRawW27dvDbdwi5jklngW6ZsORJiZiiOLBmbXQSU6K1kslgLAWUIQgLWeIqCeKgpSwgYgKikqqUSiUSiUFAxMMXTi9YGV2Q0OQLWoL90PB6oTeBcRAe5nEcZvKvpp6XL4UR3mcuBJKSVYnpKk7Iyck5KxJpwirnZfhcltZwCcAdk/zIS2KsnqeHi+BxL3geD4R+HuvE4HF3uPkeLm7zjeNx/H8jyeFgYOH49pyNnyZriS+NT8eBU6TGnK7GgVOo09VwK3xIPJb0cK/hw4ZpIM8Ha8qHZ2FfsEWNoNYNgL3Yq7BK8imzY00k02D6OaW1tDai+rG8+g3wgJZBpm8c5z3O8/xaytPiji6+txRYbbdDBiwBJIZ4JLp8V6nb00h4GZ59atfeckEdN5/JkGTIL+uNMrMMgkEg4oklkPcyqM7yNFLDjOezoDoVRVbWfVo1iarCsM0sZlFeiRMizO7sUZOiTsWGvuU7e3tUrOzsktZrISVJqa5J8+kpI48xKUNC/z4zyqoMGFBQBK+oozM+ETcYePEgZ9zmMxY6kR9mWGgCvCrZlFszTOGGNbQElppgTgmtbVSDMBbtJiJZMuEw++ZupSW5SFHrMsgoYJ0LiNWvC8OrHRiXQ9Z0jB/F7TpXcJrei6UYQuXyFE4UAX7UHOCxEmRKVb8yR0i8Q1wpb8skhro9F8LoFCGufz3w+cPjmXG2NjzXntN7lkI8y7RkWYdovLQg2gcZhx1WEJx1abDAs1ZNYIFehesR4aFy5WrYMaamsLVSrtURDCst7fCYpmhsQp+UGLc26AERBnF5SygUCNqcRr0By5Scq5ONDs/QYRI1F0luvyswmZ5giP2Pi+rcYzmdtu8Fa3sf7M8t4P5ln/B9brdO5quFbixCS51jN24ak+HweuhBiMwzE1iAUMbLSzAM+SoDNfib8p3MPMlUplYKUHSCHEQoabTvZRKpRwoao/AUzISpgkJEQkZVCsvVMN8TuahmJmYKRsyBFJFMjrALBKoq1kiVEtNkKZyKFFSl6hROcr8TJqqurBsPsGCiyFFG23laVKUHEEMbb+IGGZbbbxgjIgkpLE5XWyQRkmBWm1TvLunsFzByG05R5lHRUUSw4x2ATOJrauHrcLrlF0/w/wdu5Jpmr2UyvJd6uo5Tx4UZKsvpBEKrjXbmGK8DAA1zE2uLpdJU1aMPI1dMkkSY4WvXZPA3Ko2igUCgmt136gZ015hWjVs+pF6yh4ED4fFe2zwFIri34ccW5a3t1V6a7ds0ooVTFurBuxFdxGMXDBVvxbwClaKz5keUxCcnuUCMRGcYjh8exxh0Y82MlMARfrr6l6V/0YuZvWzOUx4YWWffjhr4nlyfZbkiHMqDodtmMnZD4BbTdod0VfCwHVrpFsRNOkhShQEk0lI2ibL3xXLQd6YUOwltmWR1MFXd3rjQamZlSmyLN/TZpFgpvg3BczmQyW0kXaPFPNBom6urwFdJPIsE6UXa7F8vNqBaWEtbQziK4+VzOchyv2NnZW7DMis9pQxPyuaDdluVxl5/sazFlbZrcyw2UOXX5Dpd2YBp6qIU2E6C9uxElpGqjGw0GEazsD6v3fQJNcKam/v2vsSbx+GOy8h2yUK6dj8zuGQzikM/56w4YlKHN7LuZIZ9qidYIQh032vxyQz++iduIQh+79n8OiQzZEiIQhPV34HBpRB1Ehe3uRkZN9clsRdcXzEsrKzcXEXToMhm7MMBy01lpBIgFRi2BBiLnGQ7SdeHJ38hEF5zsOO3M5s4kXIq7yzEImXI4zysUdhfervX74o93C9N+f9519AoXLkDZGft5QUaN1MB7fRgDtGWMuWbuRK+8GRjelH3MxUq7zXyzS8pdaAwtAWuxzucMgxDXZ6cmKE2OacS9jiWFASpA0xbYi5XZpmCnm00p7grhc7LzLyvreQC9PcK3g7n1PPt3TQX01rmsWXhk9I9a01dFiaS1lCjlHudkevv1sahgYjbe8haTvDv6dKZVRdw0r/Cij79gOFqhA3Ewn3GWVkORmgm34ZGO3fZ9mcRkQZPuHKUr1l2mwRo6lzFfvGFHuyF6c2LPcBqyHAWm+GwYbAorNRjNcj41GMTZmZmZmZmZmZmZmZmZrmwW6ZC/MZItZKtMkxTL5ZlGMSzqcTebPqUzp1d1xKi2M9G0wEjIREdAKmeuQEPQvnIDCJtAJAVnr+2nmPEBQxmGyYXMJmTRvD0pCIcZWimTvQEaoL02aTIcIx7xaH3UEJw9OZqSishgGCkNBrZhhSVQB5X4W3m68btoVrmkIbDBGbOHDhMNAsYXXDOUDUVgIYeEYo0DAnmqswDAQGQMUJOc1AkZEGZnnALGF6sK293m+oF9hcYXQtmlEmzdB2hj5xEgwaPhGk6srrxr4DzJVFKlBBisGxEz9BVILXAk06F8ODMR6NxEJtNRjtGxeG+YGKUMczSEKx727PP1p9BRIqrxWAzXi0JAxFuiaDZJE7zR183AGBsIKCabBHwcVpidyeCVeSWRyjQcaajZd3d3d3czd3Du7u7u7u7u7u7u8NcCztwgG0r6S7zdQ2mw3AvP4l7jdvYjf7f46S3rQFzvPeHwDV4fVLratxhtX8FawkeJ9xkeDbBPAsOSy818I9U5YVpwBrW5mpGTRKWrB9zX1R5RWoSyhEUHDEDYjvP9DusvIbm/ZzG9AgmB3TADXMmNbqNVEVUz7OektZ9F37oUI4qYrWRFWMUCyVV6J7zl9bv/MS3vL/Fo+G55rxIK+Rx+QP0Bxz3PohYLBYUQcU/ksxXJkSZkA7FQm3XxnwbG8rN2OMuxYMGGqGxaKMQaDM1saKDcDy2uWru+AA9a5XFKXyJKIXgz/D8IdyO+HYDlcr83Zu64aIVI0eL0AyGB3QhEZeMXblziegbIyQHxPQIhzKuyLvi+sXriqAVaFytvUzM3Llcq+c6UpSz+p0v1q854Xd/YOUTS1CXKntLTX/7mp8vYtz5FGG/7nzv8+g150OO8/q016Mz0fQ/10Qp5YAxpUHZ6+kl2y0/lrkLV0KAjSUK6k4OVXI0a6Zb1iQbkewoLCyp10YjxmBz5OGAewM0h9Gzi8nI6c+Jii237KmB5t2tsKMTg6nDSSCigQH0TI19fFQpLWx2uh6eLr7Wy0Ou10u6o7KFYQLOlntNZyU9Z1GlroNnZauBZ6uFRCXfj4S3+Skg8Ax1MEQKKb4e2nOfAnb2YZTFZtikakCIdB03h1pU50DpUCogALyMUwNNhnVHjVOjDHbB7HL4j+Bhgd8zFYlBO/C0i7azKnAYcIUIoPErpLrU1jYikVIFdrihluXV5i8aEAYkOd42hz54xJ+a+lcZ2UoQAgdfI8s+ghCEbhRI1ps6hkGDIiKnuYErIIFgFlAfO6DBMMNygm76GQAq9hWKym3snWZzz69FlKYJ4+cwNzQsSmJjJCjekR5+dPXd8ipkGKiBMGTLkHyWvdaKPYWN5WfItMw9zATSydnwMK56Kgac8hdQB0q4cYW7VlSEUo1qQmtoYKW0ZdKDUAMqXbqDKq2dsWrNEHWIpJO322fudkiJ1W6vr889dzuLdXqeOId2509nscbBxq2ETi8DokRw3y6vr3VlEBGZmSZRM+7toGjBUbOfIfaaGsqdWEmNsaAZjRMZsgz7skUrsbjziX2I0pRZ/S8kKcmRIjhfszBNYkkdizofSI2XblRopqOtPWMF03GsuiPqc4zvLCKRZFt50YB2+/RAGWUBty2wMrDZil9AjBmDcMS2O4xueAUs4uFwhxyg4SkTnaQGzu3olR0L2zMLUoQKuyFSElfV2VquhS1bJ9jm4diFNQ+zbaEmhl0E51hwlSVFFK2okwohKkYM05BZHATbfvw65E881MaDG9OFQSwhBxKWiMm6KY1X8r+UCreOp8n8jkJ3jI3spNMMaya6WFY2p8nbYR6pxPACKBVYccITwlDkZ0g/sXgq+ZQ6EzUmu/mGgiCZGL0ztQNOnpU7Y2kHydGPSleybSdNYKBqOaBkV/Cl1Exn9zIwx4FiEqsom2LIfRMZtX2uoZ9uB5gswJjVF1JK2zb3B66ZzZQchkytvEC0hpwES00bhzAklaczJzo6uFWJNjzggg5CxmPJ63CF5hqUrVGA1LDiIHIFYwlTVtpHtEnCGzjlJi4exWGHoaIDMI5SqNTFs7qEtGlmAm+5w8Ha6kc7XbtdTPTd5OF8DZxgtb4TyLLbdxrKTfrms2PwPEY30RqGnD9eXENszMGFCm5INBIBmhCEIAwupD7Bo5LGPMDykHuVVr8bDhcAahxzC122/LdPkLGLVDK4uY98WMV5JN/QerPXyil1WhSsUqYbfpO2rUyYqVEignaxxNgphLdEQNDOzNfk9QDtjSqLFoQkQDgKE7r+yTLgpuPTg5dV+2DfSjDGApmVntNNP7rGzvvFpbSBhUhpQwcodTDnBqNg0aeSuG92/3MtVZ4CRj2m1fm048GC/frUgi35gOGODC/l+xUkN6iOvcCTdyKiNLTKMqUjLdu1YPEI4lNTMRmHTzloAxGEAxCTqAOWYVeGOVKWM3vUjnTx7XIeQTLi0YmKRFaAG/zs8yExFyQNxBoJ8VwNaPLPQ4hVikHh6N+XMnYCHrdbVSwqQNvMXUsoEbRauFqwVhCGmqEmDCDA1mEOG8Ke307jT1Fmed20MFmEhjQGwLGy822OnGvmLeRSoYqbCvOULgoy8eBSDSaUFwTwnyJkpyHsuUsFM1LOtAMJbRztYcYwu9KwulmACZHcyxkB2RRCDRvux2KiPWDaKYpWHegQej4xVEjLvIV0RkzpHE0GRvLmLlVb7OKvP7llLxJlrQ12wlrRBWBmDIhFsQ6WxBRqhGSjoKxK7uwm5oXRYLv/PdY/vf5GzAymN2WMAKhNWlfjuthTBjrfr0dcFgsRzNsb9BmNzlOPpXBaQwbAMxixbTh7ff6zE3bjPus/TH4PAuGr0N9emjWtGN5JgE0Epgyu8ja77Bv6HBZa02PN71RufZ+/sxiFkGa0GSEEBqcuTe1KBiBhwItasMtvTYaRdemSALjbTM9TkEqIzJbK+hgUQ1zVuU4Ew2HhmEww1arXvTW1JL3Ji6eKmTsozAbNUwwxBY2xtNjvOTIDJHDV/T5nE9qa0aVJK1Z/B1ZYRCIS0xkvVrtw+qqZJmB5VeJFWOEotZvFgC8v233kT8GzIh3FXFqyOlKCiU2BqxLeuDzglQpSgerYNjpmwqtfr9LHvusLA9/E8qIWQLTGoE1EI0qqtoPw1ywCBeyCiMtNpivPcbYG3qo/Xwhm6O92cXQ23UvXEnOcBMAkhIQVsLUkgghGbUXRRtBROC4ONmZmprxLhqujZHt6xVxtSNGacyYYoOok+CAGCspl3jYmlp45JS1LI5zbjx1Csg2QUFj2qk2WyyLzYGMYlh0Lv0uAwZYeakNjdmtDupm6jULJYmvYXhXLdbXbcuHYXB4+CoUpTb8Xl8XXbnT8rcev5nEylckbe8JkWHU8UMIiEn8D1cs0nwMeMfrDJxLdBl3rKczsMld0HfRU6o474GqbMImMC7vtS5y7MFtsgThgDqETmWOYO3Mbi8WOHNgW4wHpRQR0Awg0A+BKAZDExQzq6m2nqf8LRXy0UuxN64ET71g2WDZk15g+rfpcDfT8m+kUCaBKRXBGUZ1wgxcm9aoATpt4cwApw+USEnpJAjCzQTxkOTEUwkTaulEiXfQ3GBZvdz9zn77vHr6jOF++NNISbkoY8nHEEDhZAWq0mmdziDSZP4TwsZ6YUWbjlZIvJlWPMGkxmtprnt2V2TLg87Ow8hdnYiRgWICtXs1bPKelYE7T0MizVu5zJ4YnIaeYQ4KDDMizEgeOqBoxUQA+4MwM/V84lS5Zd2/+ZmRl6hlziLqxnjD0MzKru0PZttmPktVql9pGBVmP06FiXB6Pqbjt/XNKjHyGjpskJRRv0/RpVHKRokfVarcAq2c9GTYfB81tYAW3OrP1AKymPEKbO8OeBE0tf+recrqk6VIxU+OgGUiy6Cz090xsZrldf216cqCXK4M1FQ+INQbxIl6BRWBqWMGGBxDQPVA3d0RISCcTFAx2DYNc5Q9NKmT8pzAJiFgxX+f8dv3Pk+hJSN+nudr613d+xb+nlVhJNlft8RmPuVJTuUUP+8l9UaqqsXdxUFhd36Dh53rcgbLCzgoozlxd3eSN6NWVvjuYQohB/aKCS2F40aslxFe5/IitgkrpiMkmzGEz0WjA04BtCGvtr/GfWI3EwuHDdrpDgMN1tyGK7zw3CchM8s5+bUVdOkOkJ6bKO28sAqXbEaTKGYcx54w3kVPgFekRYoDtC9zTxs6dRJuJCEI80Cg2ezCKesu48aatNO2anr0xOzaEEj7Nn0ACAOk6E4F6sHnaIY1Vevu/IgoS9Lj6rtrcO77HCFReYkgGR6YWivokyk4UEqGgOzb2eoU+6SKIscLaaJGQarrweV1BI2Vf5l+zmAmZHdyM2jSiB0dttMAwRv13N9ZFmykmnlZSV1idFuzBFXpYAvMsSuZy3Re10atXE1rdjw6bMyCBTwCLhVhdTFenssvAjRQ22CMgQGyWjs9mFzUNQ5BENR+9nEVdRIVIwWm69LrlApTLrDF8pm8G60bXtbUVVwiG7REtMcXsfZOhgatRtiNvskAnJgdUYBQWZ9mNAbhWMaA7iVauVRPvgGSitEZmR4+RWqkMemXZWKddPw5SbsXkEiJJvOzhylktZbEa0esOKUR0hnHePQHDGRdlZzDwGQVtSYkiHb5kfvbj0sb11AptKKO7Tuvrigi1LtVwFCimWU98caW2FGkICY5t0ohb2dHhndeIiBbj0+xuT0IZ5Ydsm2JF3xDFew+su69mg5s17NlCELqCyGQvBmjXAZMpy4FkzrjGFWdM3SulifE72cIrLqydhgDYNscEwTIF3sMXIsbo2BzqAp8cGHWqxRBwgxBy6rxphZOhBMAzyeVoP85lW/hqpYx46VVJjWezUQAm+lQ4zpo6jg2kVixTimTmqlkklwGOLCENCEkcPmhQKVqJWSKPMzL0I7qc0/mnfOq/loHHv+aGNfVUFS915b7fMQUWHLoCqHQFauCcYcsqSEfYPFIup+Ap8h6Z9VXjF/X15tP1vX3TSIAnmgIfNJxPzsEKggahsjbi36U5BrfL+dT8dbQLVWv3sm3WsyRGO8nyN3nGS9fl9Pp+XyvmbEbJi02l/cUArcnZaqyOErEnq47V65nAC5wqFbBcWWZJq6xjgr4k6RGxWTRR6uvJSuN3Hg1SFZa4gVvGJyiiKqQQg6zx+dralzf9LzW5iDhGCuhsa4Vn2KVogL8uo/1Ux8jLJVOIRQ53S4Py98EZxYB/fOI8hr0InHD5oBg9QIkT8ASTB5pmFXTxug31ZO3JyoczWeW3/GlTJxREGlY5fiACFUqTHYj9XwBrbUaWblE2BjkmV2bMeI4QEs6SODm6aEtvpRqG6ZurDnZFnIAxF03AEopxpXsmaEIPg8NUeA74H3wb4qx4KgkG02ExjcgnqhXoCNpjrROCFbS5hDw29U0lpaWYAjZ7gSNhuxvJeFX5eiZDRjQO2xQS/SPdcelvve61zu+529dR55seien3O1zTAzs+C5U7WlKGke7bOx/d76f7/jvDyhWGhgmuA0AxAYDBbm2QRuwNgBAJDBhTeBv7GcEEk+0AZfBwDEcwMPsk1V+gxzb6hWD050vTmHJoKT5IYCkgAkkpOoGGTIePaCPK1AzzjVYyB8fte7NMwUKE6D9i6vvvE9LtOl9rx+FTjqohEoCpfZCv1/JGYLbF4Oo8XE1L1Pj1EGQZWFCO8AXQYBG50rHey4U5ZCKjVRDUKC94/s10PA8G29sPF5Nt+TKAS+FxfCu/7uj4aK20pJwUwa/KY8HdJvKveQ9Q5sQNV/m3LpgxkE5VEZ2OOEwleJAYnruV66xPQDM69TTVsCqnWJxzu7jYmNlYh7A0QwgYqZeRE7qagWG10i0uSQiBrcm43WY8R1Cpdic+EwYZmGGY2J0lLenk4erRmB8Ej3CM6RNeGVMHE97FHocUhHJ6FnNDQgw7qtr6raxueHe7O1r2vWMY9j6HqNJypE6kW+lgqsdTK2cR7BeiGZhkAa+9riLMu8cpTgd+pvGVwsTEmy9meqfbBPtmfoByLvIAgBgtAwMDAoQiWMvRB5I3YCEAzXvVRMBuoFFb5Zu3ChRdlNU7KbfMA0ErA3mHO2taBibGgqawaQ2Ec5WFAnPQsUN/qLu1awefkUrvCHdkkFQfuDOju4yyZgwUZjiMsJv1wj4tEi177N2u12u2gjCbQBIuM+aRJGLQN4FwCpF4zuGhv+qBGHB3u74fAobc7PnmAjZnBUFirZg2WEN54GyPItmhq8A4TuXNlYCoEwedLJvOyKAQQnxXgmaj9Ew10PF0OaxxHMzVEnUAHlhmxY2SR4gQzIyLyEBQNTQ/04lqGhQzeQ5W/7Hc7Hzb7renZb7aLLZ2mfqmSw8jgxYz4gaEq1lAEuSdomeL3dM9a9ciht1BOE4IeiyYWnoI56QSgAUUoOI5+LFixYsWtW5LrGsBKWUEP8JGgl+Jj0uCq9YDfoKUnYhdes1ADeoAucOQXPyMPwqZCRELOqsbuZUU7cf2pOUTuw3cBMQjAxAm5lblZ7fJPkzbOLB1hNcPL9QSVESWyneU4cDhgrmicr3H3cKvFT9OPC4uyXzihH05xiHhHvjCPBoNyPlU5pQp4rogZQQg9KGbsKHjxrF53tqbEgvsbHg5ok0jnAk5NT64xDDG8LsVLWFekIeglwwGgJYEjL7j9MQX95pg/cV/2okecYjTe6jABB2Agzc0myc2qfE5HkXkkDdItyGqBuwmhCHut6r6pb7OkZMUEjYBgSOUDg94AwDA4ICAGB9iEhaHeBYAubaFoWgQG7BhIMJC0GH1IXQoFgWAMCAqEhADCQgCQkCAsCoSEhAWBQJCgQDAoDCoMGFwBVCQyg3tQ0jUWooxD4lnIO3+RvSs7eL+645VspuhTalJ9Fy1f7eIAAJ2im1nHCTtDcaAbh6GBQioTvQL2AWlpTdKc/c4tsftlq3Dyff+xOsXwb5gNEI4PkFlXRSYs68bZV8ATeiOwPExMTmeZ3fqkH8yUmUqAHXbtJwouWUnJjY2DCNVFoaJHq5oGYBmSZkD1q30PSzaXDQZNr2wt4+/52Q9vovCvgDigwI5oMCYGA4IMB1QM/jndM2ENooBlULjZDY3J6uHnL4NO/fv379++qOo9TwBlgEQt2iUGqNXAY1IEZVzeSeHo6mgdxG07yrAm9PI8K2n2YHGAbRMEC4KtbF0wFFiZaKgDsPYSXe0/e53n946XJ6+r19Dxz4/6kPj7HS5m7DnZge0CgBZ4JgYGBJwMAwYAwYHFBgpAYIkGEgwQSDBMGDBgiQYDBgeZz7nhfBevu6rfybD3G844MayftvEoLzCVtQBTkd3pMgDTLlkn7OPnrkxeT5TwDpq8nOTT4ZYeF7PzvkSfZ4VWv8fOonA74T9xfvBrhaC0AswCSA4BgHguBAEAbAdELgZ3e6Z1onPgrLyrjrSuVCx5Vu3IMpbelbmzU1ZSeLXgP532JN6YVdUZ2pwBIRwjk+O4lUXPL2lHM4/ndn2Oq9hdP3Ox0Of6VAA9eylfQ4tiAKApYDabnee5Dhw+Dm+n2/V6lXRDH3118/e5vNeOOViYn5Le3ePHjx48tvQZ9zdk0aNGjRpcUlKDlJQPOIALhdgqtaJ+eWiL5kvf/xl+j5tRZ+XlJ+FfWe9zuds9p7NbjcevfutuRX10CuNnkIwI8n9yCuixCJKq2V4CvwS8FlpFtV1LfaB8BMjSXqFj1gG0oH2SMrLcNfGDHmZund+oLaRGWB5mYc/561fUDhZteuscdgYTNrBMc9SxN371QeBYIPU9UAMJTFhSQ9GdhxAA3IFMFyvLDOgAMgJYSCm3f9v896xcpEuuFOGLnrTY0K5jaVOkqzs4BgP3Ur2g22hEDzsULw9hlp1FyyY4x7G3R21KFN6PSMjB+2l0OjrE722m/ecjbSeJZH3qQTkBOaiTCaOrgLlDa1ev+XXru3z4lgNFCxvq2zjq8Q2laprr7B0Wx8fijbVXMZnI6bBZUttHDk7ZmVs2nWZfGDuoQePWQ+oM3tpYvV710hiz8zbtVbLu7LqwCsHuxutEeIMA3CSUL+OrS5NShWNzvTdgevAnIAUfYbcypw6IESLr5LWr0nSaHa0xSbq+A/Cx+Ae/zBDKLmg9FjUuZ+i0L8jLy+14PePVdhDDbbw1ssWiARssp2rkuthanZCr8nF8qzQ3THApGGIp1yk2CKSkg1gFljfyGUypkxn5GHss30jggwxZ2rmgNgxE+aQBhYd9UOJ35lMNAvdvFaLCBdfEADZBFBLGCtlhzw3aH5oYLgJpXU4CR8DOmE8Lw8PiUQ8k75zUHpJkmPXPXD3wiMeNNCBXLsQg9RdURfEMRNiMAO4IlYF7Yub/yb0xS+POlJTB3JERIFCFTkdQH+U5VA3edpto6WX0Dba3PnGeZenQW5+tsH/E9K3x8HG9Oq+vjMiIB4MEiEwOmSbPXi4LgwjEANqzqWxYro1eoavh9Ymb+es0gLSWQDkmHjimd+YtBha2cIclqnit8Fj6naaKjUVgE4nTZPZIZsuIHmAas7EPH2ydUbTs6xeGeq2lfmbmjeaAUwuRhJwTmQq2b6brYbyhdeJ0N5OtXhZwNfpvjwVByUVPCJQiEKQsnflcKQi2EwXBEXRRPrtVMREwvnlw3VUVPZ1u9J2J7ZURLE/RlBCEB8GKIpBlIiUJZiUhKqF+JPJUBFL3Q24OdHEZAVVgYoigPx73iX7y+ksbbfq4GDr7tOX2FndIIgh/mT7kTBIbAaQUrQYkDz4XQiEVwRStSysEktmX3x8PE5JKkhtlR3fh84Jgt4ZSVALAfZAyODzw+UjJYLavXlInqAHw4wUksIooUSC8oqAQ/LWBgjnegwAHJgOZ6Vs27+nlG1rk4KKFfIV4haJCyOIG2hQtCW0oubizcNM23PxejhGg9nYhkGbRFivvSepvuKUr+MuKmX9KVQINXOzrGYzQUQ3Pai27q8GsBGwtx1GpevMNfk98uqdAD4GhZJmqls8JMS2fJzVpzGQwNtFbmGnfRat+lvOowVTUWvlIp1GRovpqwMXRKwNZE0JS+gW/5hbgbERrxB5mZYnjECFUEGIq0+NNMOCtfrEJ/ldT6h+nf5B3Uj5zBIlv4mIbTkYo2pa1TxuYBo8AAvmASS94wB2y68FcbmiNPxEmEeMW3zecs2A3qCyGUIh3U3gPbnNkAMDCGJYTJIc0RnWxEBEA4g5Iix86dw9uL+552Pp5gdXsB67ReDZP6BcLM3KTEYEGwQmk2ZSUBDwjwH3o54knHmF5ecx+isG1XCmyrjKhNIX54jhCWQIpRbrj8UfWMAWyKGXsRhFMS86vAX5jTiYRUr4je07SaLwvO0dPm6K7jY/ENrH6UrpX2KbbGEbLEo0xFUIKoPI58rAEVOmEUUbFsBzMGJPVj7eY/J+hMPMVDZmpDEAyAYCenk4TBvrQyoKhFAyhEpFLFmyzuIqIuxUlXdtdAvA1SMlDQ0W4RoTN8NHrRpRMBgCKAYjA9nfWlIPIqdpzc7nTUbnZO5/bBAtx9+F99yB+CBa1wutrZW+00000000+2ptS1rbdhhfhhWus0IyoqoprV61VexKitXZ5UNB4tB4xjGMYxixwVneIR1VFVVVVVVFVFFWvudfca2eTtCSGOSZQujYbbG8Clt+/LMFcCIQJ0psIzVkj5QNyJcCJNtJI4CjEXnAQigHBudgNEMwNK4Y68ETABiGScyBI4Bkca+SqdbvZtsKz4oS2vQkaJFAWmtyofVzM3lHMAo7o/2+tvzwh3q0UsP0nHIEfj+ZtPM4YW8osBjaA6TwatKpPuFmDf43AbADfTnOocZLr+062LL5lSeudNgLcIBjpgIrlXCmLAtNOplTT7yiLWENkgMEwMlyeDan4JjBtkuCjJ9MGFqBqSY8gMJ4uRB8KZSLDwT1lKxQfC/2VARSSgRAFERlhMQpxSIjrrUBiF4QwPBijkGBHS2bF3DEqRBHeXKwucSNBjxpcBSXWJ4p8QlnhOuWYyQGATG6kCkmC2ri9hTXui1L4xeQTmB/1gkXckJwMIhAvcQLpTemVxi9KHk9g6663LOucNq+LxYj/W8ECbysQ2kn4RgGQeAVRLBEcMOOhV94G2hShEpmL2L3Vl6mByM3z4e00Tt9vdD/Zfjmo50S5BK2qgutDRFSDjTncg4yOAJzqLe75V5OVRhvTGL1cuw3J5bOKuUUWIqOFh2e1xuX+zsObcPGz5qHADSOBcRICaCaZcK9qPw6rteX2rz5ZFvEtty84UIJE2UFy5VjuQqqS6dCPacdY+JAJzIL4NqnTCsKn5lWHXcOBWczw4muHHcXxz+f+TyPI83vH79fKbah4m4UIYMGCtWrM01hbGNTxiowaegClw43g8HCUzLLLLLL1QdkKTsuNBQNFePxYjjjwWLOLEJJJPcaUdbjY8d7vO87z8C9mJcdUEEFaCCCBvpNjJa3qXx0/VeB4HgdoLNsZz27wFgwaurq6urdtFoVm1llpmMHDlmlcEpAq0CR6TihIdRHD+4WsOHYULGWePBnYjZZZVkh3mWddJa3hGingmjHLODchxzv7VFzqAQdGpG/mBzvV+9SIFK3eZINdU1x+31AU7ruC9Oli7dusC+efYuQ3THdH3R/2WCGOQGLbJSBiTrXgfAiYeVaVcrFaCW1qcRqnchlYKi5FzOSl/NgEGLoo4ELtF3Gba7v1hlbKeCYDEBOQjQQkRw8aPPExzNt9OKA0pmrbblGZjheZBC89jHU7znIEViIppZXNDlBmjBDWmkY2o9TnM0SR9/fHVj9Jfv9XbZRll76jfXbiNeJrjRAEMG0xg200zybnqV/OwJ5XdtsL6o3Z4eloc+qjn7nwE0zQknFDn7P5Ubtf4Iu6SIzzPJrl/BbJLwHfJGaA50nWcV52uYnrr8OmXw0hJHNAMndOONrsNg1nxzlPu4ZoEvUOlkdxERo7vfQw9kyRsu9vngeSDOLQPlUWdHBeqU9h09vDG3+fud3N3cl83pNVVVp8jg8mvOvVbyuT8PW8fe93Z513AeT5MM3maPBPO2rd5MAi4pkO2Z2NL0Ox2KmuT7hPCmRrA5YxccKMlhIiHALteD+Wd3jGBZ/oeiYOp7T5zx8o6FpLC1n37PyZtdpRoWsiG2oky71/NHZmvq8LuT0VgL6Es4bY2kuv0PpScc23OjiP3Pdbi3to2kvmEW1qaUIfMGD40j6Mnxej4+fWixoUnCMpkajIRkx/yUiLIr6mAAnz0OCpU6M724oDGPenU1BjITCY1qNIzObvpSOlwqkaRuQU4pv7x1gKKTQE4v+4vR1X69YQhlzJc1HGna9iDg5G+SAw6t+vG3G8H7KLoNUKHEHJ7Ar7AvsirffHBBXj47LLHG3seLKdRQRZSfnsEGPnUoFntXf/cOxVRQqLnsWhpS2GqTBEKKKAUxkDrmOb12GkGFOEMxki0DEE9KdOy8vloi2pEqQHLCLFeud0dqa8b63zS+C7CXjJNDbE2g/oD45/exrkhNWVhTKhupQJgoNSZiRSYlU1WAA2vP1efiEPB4/msDvm8y9lv8E8K3LTxd1usHo2dPp636Dw/WsECvsH4XcHMo2yhDBsTaGwcQiGnAQDTYzgRDe7pJKaiIGFJhEtJx4UrQooGwhkNNsamISaxQiBilqFEEA0MGmpgklQgbbBtNjZRi/KcNJsK4ull0RXNiGk2K84aTffPBu7dVpBz+LfDrWYMz641LtteB0Ll7/GuJHO2TuPIc9KPpHwnnP2r8F/RPQZgererfjZmxAp5UUDqPq9c3K8H78567eLOnfvaQksgLu+zAggYG28vysvw+DTeTAM1y8dOQdsBt+UOR54CMhpiSRVqRFa9atYHuBCBUYBmIumRkBmYKaZmZoTJACR3L6m3cADnZX3F7mDta1vspez6qT5cRm2yywUhlEDRfdEApqaZIRDfpux70XwtuzHx8coW0ksDSVcTTxbu7jbGPVwSLROrcJFviigFNZhyEeqv0bOoCEIANrwJd6KPrVI5mq1UHwf8+01Zs3MeCHKXsmaRc1f/p9FDVSsmsUt8EvB5O9uj88DQ5btq2dO3cFKC1btmzhQzEM+z+74eLxVz/YSWM3ulIuLiQN/QytZWUVkBKys5EmEkpXpNFHQ2fl+PxffbgRlBUMZko+IpW66kTQ96DIvY87pMul+r3mLtix8CkWY6lpaDpses2FPGPPzRtise1vGWpFMPz/fcciaRzfje0sRQ/keA12ZF0VH7qQtxVRVpU12ukS84GMYHHZx87Pmoz6xF7MB8igklVeQ9ZOsuRRtMMEZa6PeIlQfU6+J8n6wQJYY82jnwa+9g1Vw/j4+XDcGBWK1nfgEoSAFly7jPm/QyAS2wVqGpQBPPc+03YHV/H3vMPjhcKFzMWAVb6/ue4TQC7v91979GCaYGBLfV3lne/ws+j2G84+H/39nrn8pKBABRo0aPCIAAAOFKP9TyMoxIQqDo59P4taH1tf26v8N5F+eHoexc69WCOcMv9o1ms/vDtO5iir+kBlXECqqOoWAFCqoFChTB2OCsQVCIG4CHDAbiCCIgiCAWYxJBRAMQANJCYlqMBKAEmADAYgTASaAM5oRymCCQAGB5wMDQRxgYu/WlByRzkS5hMacOGxkxExBDP2mGa5+N0QBcPPz9DiR5X9PAv4MFltttc7VIBZR2CAEoIL0gKt7a3bla/8ah8P87jXeNxshHvQfWGiEmMbIbahtwDBGDaAwGTSLpvnT/fS/XSUjafiFe16/cqWFzUe254vXXuuvWZjWrrXk/P9kAl0/9s+ktM5KZb49AylNXztCpcmcgL1YMtA34/wKqfeAxQxT6/d+//c7qPf9a95nFBX2mIWNmYzksZ1Ob8vNhQRIpcwNM/8+L3qSOkJfC5vE38Xbvu2j+L3tPYnVevwP29ycC2lyDMw4bbyeJkY7sxQF9osOc77uJCuBaNtoaGQ2vlWf/i7kinChIJvbSiYA=", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "63693f0680b6c679f3798e138c73df8d", + "uncompressed_size": 32696 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "42edc5ca00b9b7b566c8110a6dcd877c", + "uncompressed_size": 32696 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1a23762a062753e306a43356eb45ac44", + "uncompressed_size": 78584 + }, + { + "blob": "QlpoOTFBWSZTWcDYoUYAWjJ/////////////////////////////////////////////4Hfe97z33unpVANBe86gt77zXvPuR9qxffHXxxctnLe72raFxu2MjMLne9zd4A77O7rj2MW+N6es8DiD3tQOkiXvX3uZme5110ZvvZ5duBj7fe92Pu7W9ec7nnvu93p8Z4ffM+lHR003W87l3b7M8LRy7e1wvPfe+p77Ld89ku7LZVzSO269ve3q29ave65pm9Y6s3R3uve6Fs6XlnT1GNZrNug6H2wOm1m299vVe7dzFHebsx7N2cwapze93r3ba3bm97vPb26bVGxqtsKoywA7uuxo00ptTWy3rtmp0G5TUTt0LeA53A0C1Urx8vgAAA+qQ67z76dziM56RU12D66Ozy6wA7ni1VXWSSh9sAC+eVOXsPrwACPTbYCd7Ud7QDU0hAATINAAAA0NAAGgAA0GjIDQABDNQ0BkyNNBMZINMAE0yTAGpiaDTSegjKfpGTU/TSelPCejTUank8phTQaIhGgAaAAAAAACYgTCYkYEwk8aBA0mmSnmT1NPSDEjMKbSPU2hqnoyYymmKaaeRhTE8U2p6RmmTQGhppppNPQmT1NNNNPUDRAAJDQE0ARo0MjTQmmaaTaAZJhqaTMEGU8lPBk0JiU/RppJ+VPKfqmmejKelB6Teoh6mj2lDajTT9UPKZNGgDajagekBk0ANmpqNDQBISIQQE0yZCYAJ6TJiaaTJpkwFPTRM00xoKPVNtTJp6RlPUzSMjajMJqemERpk8oeSZM0jQND0Q0GmmRoPU0GgA00GnqAaAabRA01ImmhJqflTxJ7RR+qeo/SNGieptTTMkeTRHqeU8hPJGmDUBpiDRk9J5TQ0eiH6poaPTU00YTzUanlNHkNRgamymankj1MaeqepkbTJMTaZTBNPRMnlMgNBIogQAIATACANGTBDQEwmBMJpoMmSbSNMI2gT0IaaaMjJppo0j1TzRT9RPSbSe1Tek1HpN6p6npMQBp6htJozRkTDKZHqGEGJ6i6gEFeWGoXbLW07vtfMQmfxtP1eltr5lM5HO+PhZWslPbqu6zP701m+026t7ryLH/70PfMR0esddjXR3rvtiJQuXf0ajpU71e98O3MDHFo3Ky8XnKSHfO7781O8UtdKTKXemHzUYl3r0BnJ4swruUDwcUKPVHRhkEoyMAEGF0MyBLKfJV0aflXmNZOvsI2W8FL8HggoPdQYO+ZnxTO/3I445An/Kg6DH4ItDyI09/O7xA50cTpyDnEETlmGp0l2vlf2CIIrU4H3yAM3dN5ZhlKTAxhv3hzL0zZOy0EwAxGNvpfD86ZUNCC96/LsZsohLBw5J/xSijazponfeHWjOJD8Lpf25BI7piEYMAskw/8MPseHmouDabRJA9vVfL+u8CVFkdc2NSOqoZGYBmQrGjp/65a0sS5ctn7c4nlSfTe+H8KN2VwF9dxfvfDshI2GbzQGivuCkC26i0eUBMMCfc+u2qAzZtyhI4TELdm7SS4TC1jC9kjeaNW2WadE0UlTCQYBtRUlVQRYa8MQsNIiGURzodKoqUFLD2lSkVq1fTzssrppfQQIQ0TXijMmlk0k8IlstHKZTAbM95qaYgmo4tU1rZadOYrZcdsfObzs1VBzA3QQEPOTIPTI0pQQB7VCDsg8qKN4ZcW1FqpzWmUa3Kota1VWvbetkZ8MTKVRWOyy2bEyV2s1nYpa7FKz1qCzJrGJXNDjJ/Ea1upR7nPc1GOtRqrQDMJStCJ7dVVVVpLSSS9nyLWrjFVq65jhe7bcuzbq2HgXt9zeURzh4WtaPPIS1TY2a+mww4lqyyqm6kqSi9VqySTNeqquJaxjNa5anMqqpMcKrLAKqqqm8M1fLqWxkbojn6IEx0al/7jON4ftOz5v7HpiRZpJaUGr+DPkVovtyfxOUGNe+84rTtHys/seNwMVoWfmaWTmqNEi/fjE2gsm3y4RXjG2QGkmrSIpjiTg4hU1TVRSN1SV2QG2oyNFgYiDFAajQRiRZgAUwSFLxWUbqJUEiTaJBYgG0ugpGY9pbcjpyt/2XXrMsfGSlV7KhPCnlA0Ot3PyPQ8p97XaoRoauzxPE8z7b4exdt78iQPDxg8SyD8NoQRIQuZFz3zt9jtLE575TC4xn1eIYPsaYbPrtanx+LxMKug+bhyaBGqDNkAcYxpMVmenIPbCFt6WbY2OgjTBv+XJsMFGe+fUaKAwG5F3TpNJWaF1dzYxst1ojBW1kJGzjZKw0waRdpZMBatB2lsNRqEypzJwu3ZU2tRrHr17Uen2bupO1Ozn7PP4ty5yuJq+XK0Y7eLP1ezm5vJ5WQ4vtrl11ZTU1XV7eNzOPm0/NwXVSADGhwa7oDgUtcamvETASM98dMSKAOETI1XZ3EwBHVaU9bixD8xioaE2luvvQRSSFxbEQt/N/0RAxWGrGHNdJIswV9Dl8SQUjVF9MIKxATW66aEJHftLwdGCKBLcGJLxWjFOyfYtC50m9jfu3OSpRdmSKpsPFfJZaoBFERWmRAqDZixbngTF4JDMGhHpNHH8CA7bSrzGYpK3m7Ft7VnKeHgwyRUSO48CFhK0bWLPW7BC4XgLlTv6sqjMYtHfZVgGAQPWMpIqMa726skqs0P1dI2KtHDOSnrYhgbqxLsYudYW3aw3mZxclgdOyUT0Z8aXH5UMniZ8QozWO2rM8QsYirEH7XY1VhTkpSeElzhpLLaRHZVBxSv2B6tiYKYgGfNgY6sFoIBirMEY3pyQmUrJopNFqYVbn/F+tL6fuyOu/LAmG/5iAu7miTPjvq9Ov8fcAD7ju7YoMnFILHmKHLTE9Hy3sCnEH/kKHlrefnuWSf4ag4wi7Uratqswk+Qr4/lkJ/WuFqrOBj2Wy0EpwhGdLKSa6Oa1pBHPXDdpRO3Ln4em5R/DZFnhi/mWX7hhptd8CweLtRZrj8Xz7LkNa+H4lLCvhYWXhNcdq7XBnktug8rUrYGfKv7yoHzu5ztjYXxlMWhfb7ae2/uLWpSlKYta1rUpi2Mc17nvY5zVLta+WGWWOfV7qGoN68swpHGlMvYlO9RjpwNpheflgSLJkpRkAJ5CeRQKISDP6vUm6GR7y1d2sFdXq9H3XG/clS7/6qXFaN5G0v72rxbpjAgDGPLGM6JHzSAPAdNBAD5zmPGkY5EV79Gjf/HnH7f2efmN6qs/F1hZuLq1WZn+H3+0wYMGDBgrXLp1euXLl3h/1n/i9WhnJChm8uDLhy4L+W/ex38WLBix2bNmxHjxo2tfv6C0mE6wBbCA5UCpslCRTg34Upyox0yMp08mR29HMdMZC1ndrt3GGTC1QjPF8s5y+J32vmxzMqvkUfHvLa5xaPaXgNrILGgBCUDYwWnFetVp0qNCvbe51FVqK7RrScNbtatCzUdTOxAxYtFq5bt27lzHjxzdM8cTaobdqM2ixsj5mNVquEnMa0ILFSTJi6+vNx5tfXeQ4uvPn06FChT3NjYqVKl/YhUIaV37SBPhQ4G7ubu7s7m7nXPQYVBge4+j64WWl0BfTuMofN/7wGoZgNdqanfd3Bed5/HV6H4K+go1YUFiG66gsQqm+xewYe32NVqtq9FmWZGfzNpbX9H8zWxxC/A4f5DVMjPa54LEarxnLxcNHTf1qVw9es5B7q1knYu2WS6dc2HvvOh0HPKBlCgjIyHXSf1qiJAiP0+hEdDofqcrko/WkQ2jk8yqR0u1/CFqc+AE0MEtRdNqjBBwhBBwhBCiPUnz3X8rUvYm2MvkfWpUvtxmjKnTSob371ChI++tPn/1S3E6dFVmGud2ZM+VJkwYkT7WopFg3oowm9pGYZF/RqLffP6sFHxaNmhMZyKeHRprNaqjXTofVps4QH9SlLoNImT9KkBVDBmfx0XknbLm9PPj4S0bvawjjJIu0f2oAxobEHvPed5JvoJ1CMtxZ9smn9RaKEAAAI6iWGJH9VcFMXJKkQWnylpTeWQ9mlTafxAqRbbbcoNq/buQkLR5Wvbe39GH1tzBAvPavwc8E4MGL37QAVJfm4aUUklWfNieoUEiBpYsC7SZA+v9eNQjcqfDyJse9xviyV6J5pPZ+dcTq88fmI7bkTBxxzbaD21HD0gu/EEVDpxAr8FTeeFJgEGQ78uSpINU/nyySbsPZAa1sxUgwhZAYyLWaqxeI2xei8rArvAXaZ5oYY2ENGeHAnPIE54qroScjzRKeKV6NR9SX6Vl5e5et/Lp/Jqun6/r+uLSenTFOSk1MzDWXllEnJSPqyUjIerHz0fHRsZ14uKY1vr9Wu1fWTfi5Hpa/pbPo8n0Y7lehyvQvHXL9C67/O8PneLwNHhMQ6C7AMfAIwQNhnMrk72+dUjzAI5HB6cFTqAnC8kySlinOc9TXeN1Gtcs4wjBEYvc5znNazmNa9sIN91rWta9zmsYxjGMYxjF/W+BTxbwoupJN0rrFmF3gd2wL1mjf4LQ5KA/foEZExJSMDURUT7QNLGKHsV2bB4V8rXTFWG/i647PM7MezzezZvI15avLZ5b2zy3gg8i3jhxiXIxLrEu8RriOcS9xL7EpsT2Xjx48zMXEnsP7dDV7ubHjw4L+UlRfmzLtLv6jhn3lRtibYsTZ02wd4xkUwu3jq47uM7mmJcuQfxr1uQUOBo2vqTvZbfQ/V8yn9n9b9fWg8Ti8bqRXu9c4koWqh2hFHRvfYndKBwXWBdU2c47TSVvqWFeosVayiVYb7o1HstWcrJSCap8o/tVEn9qq3q2iYKpV4JZjfMVC3kD0sHpU+T6/pyj+F6eFN2rj2bPF3mhx9/QpE0t+Swsb8OGaTxtRfBieKYqjkTG7EnL4saZzeHlc7m8jj8Ou2l89s1bSZ0unMS96vQq0OqzQ0Z4YrXu3gv1r16XKbYYZI3GDs2LCllMKAUAlygE/D4PQ8DsnQdBwDDorlk39hfqWV1+v0MULpabu1M+yDTxAvgvg0w2qwEwwFgYAX4Xa1btYt0XAthbLRaC0i0rKtIdotN2gtBFBiKIoihX1lju68LxOtD8TxuCJwRfGieK2RFVP1sUTZMYRtmbI4kmtJkzhdGzFYzA0NDRyeSXILkkY5I5I5ItlSGYg5YlE42PK18L12vG9Kvpdf7J++eorvNwXt0o9xrzeXtunuVmhItx8niJwnQ7o9MJCDFnsP2NfDZfEhs/2IfN2uZe2JV4PPkXg3Uyadm+KGxgVpmJ0FBpyOxfwo6rv/TivFRjJjLjzTcYqEah7uHkJZnH/0fwGhSD+QXKEGdydG/dOh8S3d7VIytkXvVz0Jf4DPL8/LKxg0dX2N+Z2ZCvSqWFsFJ1RyX1mPi4yZ9dHDt0d2QV3Gfn6GLft8G80ay7slxpECJND+Pllo4phmUOgHkfZXjLKD39bzvqNm3sRiwUH08+eMpQf0e/vfA3AdG/VVVKkBsTcaY2xPE2sgSLFxejJ0sXAnOMWRqHA1Czs6Sy4N1Y3DAAyKKNPGp5IIGKWhN9nqlSpQrAytSMj5SWls2i+T1vu4XPAglKpZZYyNWrVq1Ks8HMDDihnh2q8G78b38iJQwqiacUpL7Ov9LTwMCfxPfePo2Av1IMaYwsBYCDJmlN1vK8rysEKgYvGhW1gSgucFgMNSSm8xqvjz7X30FdgwqAwxby6n6Uy1MWFAZloqDdtyXCbi5shyO05U3MlR2WgsQXLFidROXDgiK2XHuRbXUvL0lvYV6GwyMzAK8V3TSFAjQIGJtGim6EL4uhAlKsVisXhYAywLRbkc0aYZYXUKn1cFApQc+o4C+KiFRCoD9xAMDLB5tXT1Jz9S+4VVVUVQ679+9t+a5zeI52hs9nb4mLteCWZyCO0V0WTLLB3gV4hkrAwOycStZWbNmbhOc3Kp3pednaC4U0OmimimigNeEAzqi5FKiiaqZYMYZg0geYEDIyNzNm2+CGYPZ2XFzqqVUq6Nr7HAg0YQEFsLoYCz6JheBGTk9LpZGRn7JwEiFQEi6JqG1Z6tSrduCpqkFyZU+RdXCS+vosfhhIVKlSKvFOMGNVmKcIMG03Xoi1QbClYpy1r1WmlSYqgQYNpuYJm6cLbOHq5/N1vGz4hVazGtwyuSMG02qiSts1zabbTpttulnpts1NTUtqcwOSwbBsM0e2ZpFJFGD4W5DJg2DYHQ1J0Jm3+f6rLG6SNCWLQ2htRJGDYNoJWhsGwtWsy3LNNblA1VSkY2Nq1SiTsbGxUMGwbCvXjJrQoC3OkStDYm0V6VeSvNMCUWNpse36/vvI7vq9316XZcqHQdl1KlTu6tWXq4IQAmJiYvNwYPB8mzi2jtH1TtWm+VeGC0B4dZP8+2B2bg3vWvgYmJIpSKMSjEDBgx3hwk4G0HeAygPASGzdNT5ogGlugZwIbRmeWMxuI9T1GNjY3kCoD13hFk3YLGAGrG0cLktjburN3Su02nCwMoBd3koB6Xn/T+fYPfb/pebyP2m/xfW9jr+vqqqqqtKLWtay83ZURXkqLs8IO8cqCQpzn8N9Z+/vGMfStEgo+s2PsQz+P7QCgOOYgJhYSHi4O48ik03JG22aFwrfFERxlcyZ01YK3g1y+BfsOSkphtMtpqBaDUyM/Ojc3jZ2fo4OBeub/Qz6Shnrilo6HPpqWk0Ken0cLEowJ6Zk4j18Z+0LbIvb+ziuBptPsVu9ZvlG1u6CmAIvRIxiqqgrA4FYgjhk0Qi26/ZV6CghkPFfCfzvzw5OV4cV+0yWpX8ykcsytdzP27Fm3PvX8FDyYTpz7lCvKuodMEVFRjiS1WQZtDlhn/F+8aP0P8//f8f8i3n9zeq7mpBJrkkGwr2aLDhKikTpiRZiQVGAiM/KV54z44GT18cPSIhPmOEBDYpLehtwlxxlGW6sODkrFnAgtjicSWlks3IlOfHTGQMR48xI2tr4S81tTTu3vCvX+wm12+2ZNubNBEARgRGBGAMA/S4Zj7+dX19zFhxYUGY8SzixkqMJLK13nlNIW7qECA/ZZdgpzu3luGJYLTbs+Vmjsxkd5LCrYSEL+Yq73F6/R3WBTrWW3XhhYRItWQbGnaeFqFoJ7PS8z8Sq2bTbORmLEU1CwaGMM8bLuRPmY06LxGXOYuzSZmLJidFyAlFD0pl7S1wjEzF6+YNCo2zo8BO17KahspvnEzF2F5RnNlVRg2ucgVImCmLKAJmQTsiCcZ4oL1SIWELmo0GpSHRiZA7nxwXvZc3xMwZzDnZxD3NeRBfrEGfQUQjGJmMpEqzEH8gh7ye2Q/FdAzcaH3kHeRNAUwPl2wXvYqvkMIegYJ4jMrWWtE11NNDVMENb55kOyn9yC9yBQ2ZxEDjSlEsWxMfYBb9HTItHOnCBRROkjSg5oYiNwWTGsZXBF7ifhkqSjRJiEF6Q1NAHpQc16EReZlYClLQi9uYm1DoPDnPQiga8zQ6t79mb3wQibxCJnFMVirh2xlrWsspOEnbRfGqJzx8t1u2bHgs7mr8zP4lXtfb+zwPg827lbGxnrjdx+x9v2vt8fdwPqoN3vNxY2W63O53WkgbzeZJ9nYGImJiZUqZw8yZiZWVICYf/Ck3MrjLuHAbwQcGBa1LQDQoe+QX0FMYZmjnudzvfIkVHxgBzJPgImcIuDyB++DADnOcaEOusvOSZFq78yDw54OEHCHu/WMiHq/QaJ6VMpkCzTo/sitgKDDhJeEHHysm5LlcPhZ2bobXQ2NbNzU22m6utkK20uLW0s6apo6Woqqqpbt6qqs7WTtqW1uKq4uqW6oLq6t6m5cXVzc3UvLS96JUJfkS2oRPmVSDLFA1Ruy0p0SSdEIwwwxqe6ITF6xfOoicJ0OyY3NO7625RpKAoXUXotJThuu5yYshMIqpJkIKBNk7952vDfbiyUd8pfVV9T5X8cXh+CPWnjwhD5foiGRi5T3P/m/SdV9Ee4n1IPf9cfByGMZ7fzlKq9j5lS1rkr5+4WpeVMG36BsWpetYWtdpQrT6738y9baNJkqpxcJfT9uIjCD4PY4mDfJTMlBzpLWse1BKWtaLZKUrkD1DNCT050tF89VRRSW2BCWq0vbcBKdS78nzldbqVkt/z8z5LPPQZHQfp82mmxzYs86QmSmkekA0M5YyKAO0ICXJrFChuuqgYDhWlnJZkTC1dLR8Pi5yir9BVV56yv+jis5hfXpPd//f4+09VM3xg9gJ7ML2GHDZ7OQZevODmHHevdz8f062T1OV3+HxH9iN6nHswv0JfJGJpORklX6161AMUROJDR8acTKSJ+f/nFLlsxGUhCHA4HA4FbrIrh9YW5cELuU4IatEIbkRZ64i7RG5jGuwTkbwm6ZYCV8Xt/ftWrMbEaQptCq35WOGVnIK7VSf/uc53ypTgFp2LGaVmzmF7vuznfKc9Uv3s58Upz2paPw//KUnPbylGMcOHEjBze+1dXIyc7a7PZxkk1atbSXl1/c+KEaCBP22YtjY2lzF2hhOV3MV6/nwsGxfoWEfYCFhb3X42Dg6GfxPcdvze3zuds6LuzpyYNjTi2NXUx2enXsp6SfEsl3xJt3LdoXu21F8iC13V7o1bpeCZYzpVmqeqn1NaNWwV3VVot2LW7DLVEHl/fGv36SDzg/JFW2H8bZ4W13HH8PVX4rW3zdJJQqGa1oizs3YiSqKMYmxjTTERg2AMbY2kkqBAxoqKgDEY8mEjmMkYwX/N0/l835rBjYeXUVFQtjCysDIsoitUa6gGASJOvI7ghGhx8R7jM/H6ei9D2uDv9Ggv9itQW3pgc3Qe7A0i1Wg2mhs+dZiEAHE6Z8KUlHknxcLEkMSX8O+7+h/Gx12uHh/y895iE8oM+j+dNaMZjD0d7h6W9yMNxW3mRoaeXk79NpsNJdmQNxc5jBsJoiHG40yJeVl5aJknxPL+kpU+gqVSquVD3/E9/33vz354e+b3ze+b9wHwc9rme21i1ep8rhamntvaxeF8vz9XiZ/0fgwfuj8OBZWX2z/yxA7d3Lt27Adur4BX9R3hgKjAI35hfmH3jBFP1GeBQNr3wsr+XBPF3C+vYzEUtdu0FRDoIdBDAb6sArBC7PzelzIVzxY5UJyFC4uerd4B4taMNuk46Ge9+ueIHjxA8QPAHhQZ/AoI04EJd9gg5Fz7dWgBQIfZ+yBWA+z9j3IFZ+xdr/52LFi1mdUC/w/q/ywN7Sia1l3PoAmb5IHujVITlaAFFVBC1RIqs0iokKCzTIvJySkXIUD3beEm0/FWG6hgnJCEQhKAQv5EMMff/Fa/0h36d9iDo2Up1K+RmcE2I0IhCIQgFjgARDwAYCFfABgAwYGNvc9N829T+ZMCEIhnuhCDQf2JH+lyPDjw48z60khJISSDAAqGm8Q1jC5FfIUZwH7U8hPngTwJ8/+T6v2q39/4t4O305g97Z5Gn+BRCsycc6dObzUqygUoEaoKUQlJxYt5tIWbdrwbatT4yxxLnQY8dG5y3ODZq40hqXko3pqRjJQaN8lBuv379n9ZS61Wb95U7yxbyFuFy8xguquZEboWi2tCriFHkbF9Szt3L9/7tfLxNfMkNlgbfxU1Myj8PHaMXRdAY2OnMa0Y7MzLx8gL56rWUxZSQlU5eZRhURVZUoFTjEU8ipEKX9a0+3Qt25NZz+5TdFNmTJMOA7BPwT8E/J+9f7v9eba2rLDCnADfsIp23/QcqpbRasKE0nTrdKjRSVod06efb/jx/9mH3241lpHWZwoyeIQRGSocY2ylzLy0l3QsQ0SzHdLTORokAS5cxACJema4ZKgKzQZHNwzp076fyTEqhrTMsalRo1aU+kd8rBpXRTVFNSnOQVAUVkFRVoygJ0s55kiZOnLKEpOMjnOXE1hB1N/ahW1v7NLaN9rX4N+13eAuDtVFNqoptMb2tm+r3P+3/REHv5ROzZtLQCzAsgKMD907drFi4/8llNOsJ199BiBcPlwQBXDMBmAjkHra25ubF3c0flmN3d5MTMmAZBP4dWfNe/I15UYCLFMA1ooEUkFBivdKbG7xnjK2MLY/y1DJUyAZMiAJ8ZAMgcmQZMo//m3WP2LdT+I07GrGAjNHz4zexDe91rarxdw6dOj4rtTpqST6iYZo6mXVGtU0qChYUElMY6Xd/hukKsFh9BOqxBVUTNfwlFIPVhpStGbxIURCIRxNhMI4sVIixTjxZfTtWHjeJCjnemQ5MJkspDjpTFjx0pWcWmkePIQiOch8mMciQkR5ByJEiOblixYksOnDWHWKHCiTAGbN48od9XwXbcF69qgSJjyk2s3QNtjWdOnUbWX06c8phiKwwww1gYwJzADlyhzTwwHz5suuzfRCbtgObxn9KzSet27d7cbL7FfJn5vBxVMd1rt63FZvHjyGT3V3rvd6cvGVV6K3Wy27/T4PZ/On4eVsXbuxsX73/TbZ21jHkbuMd1hyCz87Qkmc5xj0VbM1rW9ddfjNg97DJkt2YtrVnCO7du3b9u8b1Y8ePQgDDShBCOTeA/olxtZlHZs/6GP52jRtIpyZMTrvD2TRJeO3dN06dR05tnU9dlxckcSzenyRlPn2qVKlQ673ucvN6WFmi5Rud3zMtaFs4jlOb2r/Cy/259f0dXhrmzTat2/r29xVi/ymJahs3TnJjqNYxnCkrytiE4WE3avH8SzbYMGK7KysrKyMFzI8WT2JXfxNi9Dh7MpEyTDFhfsPp7DDDDDDHhxakiZAcuXDhw4cOHHh+HRcNraBNDwTazm25WZGyZVpcmtcWrLyqy7ho0aSLt3wIctvL+e6SHTqZM5NG9KlSnMVu3x04jEKF4Ub4DRo/ftIzSNhv8rwOXNf86A65+zCn3YnNWWWWrs4KjN1iPet57nvDVvM/saNKPp5nkeBxmta2Vjh+ZCHiyxL6O8a02MZf0ux4G2uu0K2qUlHVx/IStfg3cC14+M3BoXtFFlrYw6C97Cxv5Rr6PeKYxDM32cMKdtLrrr/WXXYq2pXJ6PQjWNqvLlzu7W5nP7rupuVQSBw8S/xmKxyjFN0hAgtN/cLB9YVHxvrS3t339b2wp7rjZqRdABAKrB5emXouVjNdRVZ5J7Ysv1kJb8akf0GFjmvGgC9D90ykhL3GG6Uj4TQcOBu7XaWmnc23BpXtJqdVsuZw/ireFbXvbbevv1fYcZrHxagESc4ikQCMK5QJHuv/ud3RrjXqYPWaEeT0ICpsEtNoSOv30EVxoWNxT+v+l+l9pQXuGDUb9o3fZN4wuF5wcGiLBFkYxjGMYwlog3oiNliRwGg27KCPt+Tm+d0fnQ5kNNUU5/0rMHZYgNVhugDbEeTu+R1vxroR8/GJBtbRzBEFRZoDbXGZ0DNjEjCEJBGU0krLQgnaX8v3/s5WVlczLy8vLx8u92HOLL/VgrbLjEG4abFCcwTaQwpULU7LkVtPNxP3aDVz++c7hICAgSlL7TxW8blKRoqQ4OEXiMBHkE39UnUJ76FCEIQhCD3uaxaqgALxgADl/qZ4GeX+JCBrkEIYQBY5oSyfAaXaeTEH5zQsepxaEkdTNAPn8cLpjOODfZ+h6O9h+X/Yx/M+f/b/S3EtbzGht9OAimINl9Htj0A4cpWAXB9ayr9Wv+z1fuU5a93Z2dvb2ejz3oF2CgAFDiPU351/Fi+1jjgPyMzDRTVdpAYY1ikMVRSV1stlE/k7+H2+3+/m+9+7/F1vvalMuMBH5nK8L+PHWRNnuhoDhtIwNuDgBy+ZzftafjbOMY+Ln5+fNNNz089Xjr6ius1f/JS/96lTU1ae6lalVkOsq+kgQZVYQtzsPiXJeGP+Ah0IXl5eXl5eXl0hK7awU1npgcfo6Wn+C5ct6+kkgqsXZYvo+QPyCfQngri4JB6fRgkZ2I4Jvo20qRp06NUkBUb2BoZ/V/BEcSEYV5VO1XTCsxFFE9qopQKGAZmB4xgn3G568V1LqOXLz7nc/gwcj8HrygQoEAowBwF+fzfvHec4o7MgZ2R/zjYYFJrHE0d9+/e1/cfv9KuUCXVqwPv9YIRv74v1QSik8FKBhvCaolcBUdAhR28Jmj+SfS1+v8ozWvVuvwXUmFua1V1+362jIXd+nADhtE7C6YbanBEjAm1IF8wJ3M2DbMGYZly6C3w8KpmD4WaBbNEYHCN4pjoYXy0Gi3XGK7DvvChlaGQL3GpSw34LDdyr2HvPaqkWaCzkIczAgDgMMzWNkhkyUHUYJCqZLLyODkcnTIxyonG43G42/v6mpTsLL9ny5mUaKhAIEgIQtcihkKamps2S0NBUrUtUJS5C0BKyTyfDUZ5mZ3m5mnxFDfSJhjcKSfVwLV8tZFMwEnaPQ1fXX4Xh+I0grghCLwHlc1RyBAVJko4MeJ1Nrg2X8Z/4nV5/Hq6IlOTweTJ8diZz+WkRZMbe36+91+uvA56Av0Js5vurFq51nTrV4uxr29jYutwMVBBdVx1ePUyvzJktCNBDfKlgchhKxdVh1eZA2XRCvPIsyx3kUEjB1yCA/CDtPh2v4/gSG10iDOHBFMaR5HlV8e77i1OHuml1ep1MriY2FOuYdEYr90gi49/hSIR5Y5RUlKbIIDx+n1q3I4N/ixadWZh0v913HjRb7AyFM1jHlfhSTmX0MSjtJOpprKyw2tZdUV/YTeXq5fzYvG4eZvP+eHv+H/HTpQKXa3mskO0YGJnwDatHZA1rujnRNntiFeHBiFNpGb1tbEEoyGivmGNs0mkwDOMDv+FUka8bxi9MpEzsdMIO0EFg4SK2IEHvTISFcxXXot0erIRHWEkzVOTwKriAExigPSHKEYwa4hhb4fp//ls4Hi4yCSkqrVhhWJLWivYLFlc5KKUnSlOQ0DqG5jPEUPCMSMF2rXOuq7O1L4zuKvtX1cfkZ7B97sTSrelNJJMg8/umGHviagBfyUdHydwlKU4yfBVgW70H9p7mwADfX2m1ULr3+BCC1q6JWnASwLSA1qUlv/mIDWoBavBvpHhFPspce42vCuZOPb0cK+X1VDT6OHo4miNHF0cQS0JH4waztTjZmPmRuZk28hnz8/P2VfPT09TU1BQUGZc3Le2uICVuj0IoqU7q+vqh0+3uWpYXmXXPjG5ZucrHeX2VkYzrKycjLy8vLy5C5cOby0s8yyuXFfXVtZZ1FPTUs7Vz11V0eHdWrelFdBnMbIhnF5CwJ2FCofUTwJobFLMHie1GLTNFRW36+V5mU4eY4BG9YTWrAUp6Fy3bNmzNk1tXEK4cbCC6heepSlJwTV78/x8n7LGYrcVv3W/exnvQ7/q86qm2bNm5R751KqTCqjl3xxqm1Asqwy1vjdf7Cjnrm8H1W5LpSTyfqsqXUWb7OgyynoNBBqJuFqvZi+FzWyM0wuX5dI+fK6yId+Hoe43fwryj00LVB9gYBi8nSAsN49EGZR0FfkZ0PhPTKEzQP25w0IJyKtFOScIxvjgQp6Thk2/VSHEWd5ORc9Yrndm16PoQnh/B6HzSk2EStWuu7LJ7Hft/jdW3TOwleNQDXbU1oPvbHio8YPhrWVca4jB0ES9/RukSe5xdyiCs7Q1gMbnhFaWz9OnAVL1EUUqkmZC/RJ1xWqgshbV4VWll713ZFwx8MM6xWkFk9FU0aOH68nmr17EL0O+FkBByXkjcME4cQyuGO0+MzVySAY75IjmIZkG8K/bHf2ezDi+jLaiBJQMDuelwcn/7wqjgqusTAbMzammkWkqk2MmRz0ZkyUqrsG+nyjJ4qqWH3Fyd6ZQkYWQ5Gn+E3coJzR+HX0CXT5Sq9MmO5WblkvQHLV6ZLbkK4BLuOvLTjJZAHm6jvIS1WvlJTwF6KuqS2TIp3BK4aKnbJVigpjb1iZeZ5HbJTtv2mazECDatI9v2iQtq/m8tdCQDaxnfZBarV5gFtW0ZWBFZMOqUGTIKQY195QCBh5LOaQPHp39Go7B7bmB8zVXuAoT0YrwayZMMCGHGZxJEBvCqKBTIctgD4WWWzwGvX7yUfFRkyjBN2+vUcP0/QXy3H/ZEVn6Kjw6q78Z9k4LY2fHN/npZyfaLUw2GnJ2eje4rKO/Qezxvuf0f0Zhstz/iYbLNM6INsaTaJTLnNn+Ms2KPgyUw+K0GaeWH0p+CMJWhI0jG2FcDPlMnZEK9mAtAmlkLlJBSWZYlvlgLJccqs96TGMAtbY/OCFgKq2/NQ9BpsD4mt0Ld4aiTSsCo2PfaCEJUQWZC5AVBN7gsPFhYFwIaQ4Uo2TgkucfianS4RtEwS9Ztm0SkseqTeHs8RvzqCa/FjlQV5wIWpP7ZAwjO+TQGhEyZCC9o4PibU5O3V5U4Vrmq4qSlX/ud/v9+SjoaK0Z3leRoZmXk3l733Tzg8Hv5Ndi6mdk7XF1OJ3PI53e7ut39byN457/O2Zo0yQqgARhF27o0W7dvRo0aL169o0aNGHDhmyo82XJmzJc2bNmzM+TJkuZrWTDfu5MWHBkx48ePHkyZs2jRowxuZ7/n7Sg/4rLQt5T/zxO5zj8yj5KyzbmEhCAjH/B2nn1ZfY7e3Gn7iav2Rx301Y7lV+nIyMVCsqkYcpNxG0qZT52OcxLpRJBaggjLARSsVJCGakrrOlVhXlOUk4AfZzPMzq1cfrhOBIw39/2rP9oCFgwz12S+XUm9hUAvASl/9zCnlDDXMIOp8X6mTMxgP5rNjLn+524/NBOgK4f2Bq/1B/pafkWzZffOGk7FSSAvdOtmwQYCkZyKKtC82+/zf5/3PvYWirHCr1Pwi8isqmPkfM8zWayW5R++s5Fwgv6QFB28/fjod9uAxSAF+WzrHUChrGqMpzrft7igc/4SgWIxiNCPaEwQTU/M9HTPM9Cr18m4H83tdn/YnwWraMBF0i9RsEbFGqq1F+jag78BKG2CpUmjfYXthG/x4lWr+VS5lS3wcezOMPsSFRg9aZDa1gqAroKZRBIe3j9QgYKJjCCZm4AOAesQ+zXLSU1JUMtDKq3s/icxqALN1HewJF4tkBACuZcADbEkT0MXv0FLegSlKMODAhSUJTMsZYGVVj46rWJO3cXwci3tFALy0CArLmqQ1voJAVMQTIfutj/tc/06m3T/g/h9EmTVCEAm0r6NHZtwf0n8WDW2W49X0EECcw66PvPGjbByt6zvFqDbfwxfaq8q5dWUxIEdVgZETg4OQlJI6yaJQlLT07PKVjGFjCrNyJ3Mvc6HQxLHSgYjL3cLebzW083O32zu7u7tb/d3dvh7WXm8ba5XJ29Cf5W3t7e3t7e3u9Lo+Ru7m5yt3k7u7zdGmqbKxstK1tb0kLA9hanVfSR/WOe03kbyVVUa3YLbky4yw2npotK+qgqmqq5KPjHyZqq2tcOK+vra9w4cOLOzpa2qb1FbVydTW1lZY2bhw4cW9vaWVhXWlnZWNpaWlxauHDhx0P6+RMcczsCBpIG8uKcpjQKRNB0aTTcjwnKOti1WRhbot2WiLsZYNC4ngwjDTacj7NuBlfP+gT7s+aepszehUikka9R/oBGm21i8qapp3kZGa0sa9zEMQxzW4TZ9tZrTn29Hp6czIJ0cmlzc/m+AIR2iUG6RGjl9H4Udwh8D5rqlOh1t98vCfWAZa673CSAJIA5hd9JhprZlDFe7TQBWO8YsOVneJDQSibCmGhKqCLV7NhGGN3TPl1r6GKBiDb4yhAEmOb2vUMr5nxsP07z4+zqZ4toZfhWIx0IIJmAYGmb/1HERW9bnv03CxC/F6/loAxqQgG3lH/rzJXfpWiyP+tceP2/Z7X9oyJEWDGEjEt6BlQWvF/x0ZdZ4Psd3usY58AiWMnRJhF37nKXgWxKzLEMn/pUmMetAmXMwv0cj5MxRvs38UQkZTV7wYhIPRj2EgwmYb7uvQ/w/U0r3Auj46x1cKfYRWc9a6s0v14VloI+7uW1a7vna3oyERSdtbF5cNi3po2p3mb8E1NS7GWps1RkYh31SfPVenjm/ux8Cxo0WA6rvBEu52O12u4u61zmyPWyeh0MyzxWsz16Gwp6OWmuvuX+7h0t11vN8yz63V83sXWv1ex2Ox2Or2/N7PX7fX7XZ7fa7et2+73aa6b//qOvgP2i+T/FLGaxOIa3lb8HLcz33bD/p6NqcPhm96q4be7Oq+3z9q/ae3rqKgiPGrrLWzeRu7+7u5K7u7uSv7+/vYu9dX8xfunTp/d38rTN27epqqysrcOvsbG2ur2/pry+v3N66v3Tp06dYGBgYOFh4nVodPC6E+b2en3qf3aXzDIVlbi7NSBmdgzQh7vcytx9Pt77mOeR1G+zlnU7W0gZRtitukAisJEZZNHKQYpDKJJQkkEhkkkiiwSXl3+4vdWPfu9UfhOqo+e6i86faciUbz86H2750/sv4D+VPi9cl8ofixVlN5iA3omSwDT85QNMuBGaXZAgBhKiH3oxE8tjICREdort1lhv4LcIVUP73P+ehiOdu87ic7X3dqqYDm8uZ6Nb51fWN42lpKGf3eew3C737/TuerUVGsyfR9+UWGi3DEjkdvqV/OxWcj9Rr/XCAY8Wr+hmwEo0SWhJbqpQF233K6KwCAgLN9u+mga8IwCIRIEQOdP/j2tBs+e8vXr/OyhkkYGC4uoS8gAOyGTgRXq+2B6Tn+LnBF6qiVKLBfCILUdblnRfY1COJ9SH3gzkkrdrwwDe1ZjhhoGqSOJF2/tdmiuBDW16rODepptYbsDnZBsRJDW+n3/qSVGKwyh/d+h6H7UldmX3FEdxuIEzBssDG9dwGNjDmqHaUiDYcBDOHIF6+1Pga5E/cjc7XX5HY2evox+7rPjKl7Ow97UV2uzxdbtbWz5VB1N3cu/M8npU/U8vyqWU6k91Op6fp6ur8L4X5nhb3w/h+92eDWGrvWkcqfSpUr2DA+dvnj56+rakDVt28l3NmxYsWeVkyaufW01KlSxYsWdTJhz582TFn1M2XLm1M+XRo062tyejq9L6XwnX5Hzvp+D0Pe/SNeqHqhKqjqU6vd/M+hatfe5iPHawRmk9dehINdBnhA0SlkOBzmvTD7+d0+dJJj/HqeR6HvfrvZHow36PHay1V7fEpjbbbGNjG2MzQ4n09dL+B8Wdrjk9dDIvq/zm2Ub794fsfcjGQJ23X1l2wzmknhoXHamnbabVKlHuacqGbFA6D95P3IaBoJbo9mC8vOzkyPnqPyRDqbdvb9q/TGh60L5/H6vV6sFCRIlIkSouEhFYVgKCnpUmC9bWZNlEA7bMAiSobLcNHjm4VwKy46xBX9jxf0OvKEtlkPtMIDpvEaUWmPN7/2Yikb7/Ujd+LAUrn1qAXeK3W7elYBDumpjGQA3XftwKwZjkoV3amhVBaPtn+Vk/lfVvuWrhq3cOVcOs7v1fX/Wr+p9iMBb9VCrm6YMS0GJSUIDIIRocqJSSDgAGYgAqUGWUoohQh6p/Xb6+uj5Z2/c0aEFXyzvgeyRyWAYRz5Vl87UzCjYTJBumG6CTeBw8XMytSZUKyjQYDV3AbBjATYBJrfPjoZeYTwU/pgXsNhtvRD06Xqf36dVqs0PXk1WyJvTyHazthNzPxLhupQ/e9VB9TkaEjRkjH7kDew1DtMEYI8BJiuZWRWoHfUitDssc1uL4NlRy97CrBlpLFqChVX4vbaV+Tc2DLJFfO5ug29n5WKC2pyaFmsa2SDmQLqtS3R9DwUvcej0flcjWseJ9NJeqqUwYSzbJFXWc69khhB8FOLx+vA+mIxCAfstTa6GUEaupHK5GD3lqJGwCJejoRtKrVi8v+WjYA+097ke4R9RlucZZV7MICNPCJJgzBg4g1kQUYpQbY3qQVFGKTzhvaXdy4P6m48Xm2uJi39JWkDRBqCTSgFYxNvmK1qK9CZ43XiARLyDgFvS3ml+lLWaLNLDiKICp4Pc97LRiwRrfd73cSIp/V+r3PM4k20aNujPDPBbL6Px7uyUO9u2e5b5VGs1u1LtdFe25Dk3Dt20bzcsT3O33OgtdpBgxd443W4G33YA3CgOLllY7EW11rj6L/zI950W6X5v6C9vma240fud13nu9GTMWfAv0hYDAAwr74PK72abPwpKlGBTQgMSMkMGKWOxszbwFrcbG2XQ1LYMSXhauNxY3rloHqgFia/h9/zbaRJ1MuokCzQibIzPN828mrNAAQiJIQHkfVO1dXEHcBGs2CNkijlmMSOWY6MUdohYgFlEiCKC9ilx0Vak6ePOLNB3myySMgDI26z2cPd15XBtfGDk9XWHCdnV6jOfK173pln7SW7awGYmOBcwMGgB45X6qCchU2r8mjTk0XxKMBNPqz0pX6t0qG+u9/6rlYrxojBzdH3dfUxfOz6nt8eAsZYjWFCChgwWANWmrLVlqWUkryLEYkZbVdrdtbZrHa2TTYL4TQYLV80HstZbXoNe9a9Br6LWE19hrZtew1itdu1tms9rbtaDXetaTW4a3bXBa37Wu38F8BrgNd018BrsGuA1qtLi7o7HPGMYxjLiTRXzBEVMpLCqsHi1Dytar6CVXtqKyr51dJJ2ZUCej6PtJZKc4BgMS6BC/GdNgeODdwNGTU4Gq0OEs3yHmw8popEyPBjzd/lz8jU7vPn2PF0wnBnp07W1rbevr69dfXGu2DLXZa9nmZ9XPag1HxqwNxOodCzw1eJbUUWMB0XB5PYl1N3vrDtV8oGpISSQlKVgWlqiAtaDOvzqgPwAJfNAFLmwoAQuZ2W+SbeOWw5w2LClo5zBhMM6KgCUjiIVlpVHBv9FE8N5FBjB5/mDG76vmeeGw/rijP/1/+l+td+jsLXLuZZgBCEMG8gixtxEYpEVRvtHxAt+2d7C+2ytQaOHS3XRaE2NCaWoA/4am6w/lfg+lU2+hWzWaSvIGJioL+JfNXlxjgNivtPHUseI15fwtXmfErwv5/+KRy1SeBh9a2dlvz2+e23M2WWN9Q4G0tliGxUuDybyjlXhzHZq29L0Rg0uuzhvUAyrJZc8KhNI48SPHkSaIHLKN2fC9cvAfB6wYACTBgygMIBg+MiGXwPB0vqJCEVKgIODbY9hCwsrVw2gfXk1Tm8cXMurV4d3nNVbj3frRPT6HGOe+Ocakc1HIYqvekqaVK37f8rzPyPx/yumbqT9HRqMOQxbH2vfdS3cphzxd0HahWnrT8/cn5WtXm2r8uJTvoiMuzG8sgZ+f4BKEgd/ncDlLVaiGIcMlGjv3r5F9HV1lnmEBt+6t6fOPufc8rZR5PtPIbcUab1fwV8BUjpHU26K7bPutyDUV+5RywGWPOkG26C0F16xf2E/2+d40h16e4o3bGmNMZhXIlZguLPtK+0wijw0gkmL3+neeIB+1TJwzJ3dhrCo7T0mgzBqQhoQFWIQu87n+FkvhgmJWlBJF11eItuaCA5+tneB5Wx8uPnkQFP2ap2Ngi8hLHOQhJhidyoglv2Yda+V0Xd7wXVYokF75dorlN2Ztum3mOiLC1lSKJNjToqpUYvsdRvT9JkCdG471KBda7W+yMkvNeW4juSIIDlnELYhSZgTbOrLXw0a3Ez2q9SwV2kWWQY22PjdrTKAhC0TGIpNNms0FMAbAUuKocYz7Ku2jDVPtGkjO8bS+xm41YGGikc76eWu5wRFQZjSKPr16dUxqfm/E+h0/W6tWsYGFaFndTKRihjBSJkZRmiDMzCQSEAlbfX752ltFgridxo/QUI53p5MWDz9ZhhqGqLrLhQgseLpB4eoobc0IPFPDLGvqHC4SRwzHdOdZPK0VolaV8DzvetxD+Ukw7mNn63MN3pXtTRghNmEhmE4NJRkVqMgpdvt+GKxwt8H4sPIp0iq3VFj6u5hGdgSgMUHBll4yJEAuMQXeSAH1oIDHMi12bTQgvHTwiIBizH+z7rev+t96nu7bMNtXqj0ZdIFukQEEOT5XAF3wayN+bSExKEKJSlCTJqCrHeQcIUUllSGYyMIFh3wzjRQErzWwpS48vFyb71r63dbyW3da5HHzxZ9lZ7GNJp3kCCtWXJr74UbGLW8H3nZ5erz+X0el+NhVL/TXjPifY77/mJEMFOWhMwoCZEQMiqJCI4Zm4DrJNmh6aipphVpU+SiCJqAxggopZUnJ8n3trNp0du8xi1rFaRgoognai0Eb5qRrG1RxK2pSGYZ5u6756tKZUDCGu83UguZiSJfo9IyANh71pKI/N97QkikwGmCbQDaExptIjEiMTY2NhGB8xpL5bCmkm2wbSQqjEbFiL5o+x/jgio0ftsRU8qCJmjy2jFaRdggya1nTBts1B6b6ua+WEsSMQYtRzcL8h8Ar8HxNtHZd+I3xGzhrhq3i7xyw7nmDuRtuSSB0IYdWgnJnv6nw9PNvEto2MZewRBiQ6apxC/rwUQchCKOgFHEl6HQD9yf729p/OaNlmEzI17TE2NuWrNLKK5XhFJTwFPHaRItHtvJGLt0TbvQoXbXR9WtSFgNFQ2mzj0lp6ZDweG8qZmcB979D8hOdDdFZq21iwZihUwuBXQ409jHqsd/P40OXbU8a/hwIqbKbKbKbKbKbKbKbItkWyys1o2sIBcrZdMLkbdmGLamt04KifSoKVJkymQSgCSSglzS0NMUD6EKDC5b57xX/MgzKK1X/W+kC9EhPoCSIrhqDTagwL0+LNgiSUjD5f90+N9Pwz8raSynLhLKazf+YfEsc0PcInTEh7Bzg7g52qtcnVYWFhYPf5/i4HiWY0HDCOMJyW/KQMBElF4crjUaIaEGVNqjxe23zk3amA09Fwtcr3esyGDRidPkkSSGMgsrVf6VOG9UPV5ie9wafDdWJgAbrtaulQXfO+qZcOuQHlrNo1UmY+BBv76N/JjfwI38mN/BjfcRvsRvke/pv4M42rzzqNHORXtogV7aIEuFQngfkLTnnGri7vEKnLHUdVQ7qgC88USAiAgiSDDGhsBxCzfygd0fkNUcIXxod3FfSD6X7EUeN010HXLcEhqc0OyYWBEjChDMKdMkdQgrHaSFmTPRT04lYqoDVPNIdPo/Xm8ualsdfsIl/KB5YMVphtMNd7FE7V47aaNdS8FSTcbHsTtp1qse7AL2/UlBhN/D7qpl2NYDgB2CRre3fu9PD2cNHddb3asIoplGvtwO4oPJUTHidtDlGQIqjmA6Iui2e8sdXrKjr8KqoRhxZYoxXL8wRQRuyMWKRiuyjk86xGOw37RnwNWHggJhZrQoHq4uFgRMZHaVWqDA47yxcpLOWnTiKGDXwadrk8r1vPzaPWdHTuaLQdbvBIienXXXEfrZ++y5VFdCWeCgoxee0jQGmzD3tmHs6xgW3a8Hv8cdQg5a5crSmoNUwyUh0V6dRzpggfLaQrCAotJ1ue8cKuguZAQI4Ma15oiNfCLz/aLJ+N8bax+jl95o7lGrb8fg1W64xt38hpKohH6tSm9NmBK8ZXT8EgiHQ/4bfbwbxh04jKgi43MMBJhhgQYs8GizGCKT7Pc2pfx1vjkucWMthCFue01gpU2QJvSckFUnMfAW2zCtECgUymSHhIPg5X5XnYLTKnZdvUGQbIQUEyK6E3ZkipGm0hWr2Iuw5l15HRnp5O3wb7x4eP4/Apau84nFusAtga+7w+R2l1u4RhlvRaoVnzFgphYMAwDnh6Ho1We+os3Y9bs22vG8bMLRm5em2uHSYXwtQ22Qw7W1F22SQlEB56SB8P83kevWx+gyomo2QQfN35krBiPKzFsPgOk/muo3rRz7b/l62rs7TF1mnShspoY6kA3Glwe9dJeQsq8UNz9P4Hhb5pztsNIZkinVU1mKgRV3vnql46x4Xj4i7P67xujzaJ+JCuFL4Yfq/7ISBbnpEUT28nJkRPNDGzEQYZdm4pjUdS1Io5O8BsGwbCmliNNa+EFbmttUn4jqCUcuyD8dqHbEO9X2trX25diLYdQSsPEEgGCgSEEwxAVIkt+wM+3RGjmhJIOYCZPejJdnI9ARitiMWSS4LlkIxD7Y1aaQr+lHVzWZShKAY+PjqJkswOBm8IPSIryLyyrZQhnCUEEa/W97RnVHLOgfKjdxfupfqApEaKKQrzi3NtVSCVqVmnLDRRZRkI79E9KZc/RktIZdQ0o6yXDpA1CxS6xGfkC1bXeVbc7ssbYQBwbY2Ki4ILpFQYQQEzSbAgzkcV+5gtjbn/go+7rtcFeR8Ikka3qp6zsw1xevcEeIjCI9gW5m9hQ+4281vHTpBrff7T8Pd/zzIoaMhotV4BlB2OkZlqjAWzoStjMDbmmzu+VmtVVVVVYJcoGAzZzU9Ow/isjGinD3H3XsehwHN69OAwAWAGAIECdaVfMzjmF7KCYfBUi8r5Crbkr6u++2/o7Tj6PAjf30buhk17iK5eM+jkD4EXUpQkiKd7daNBPktVAr6XvlKczZbuKs5wFkKwbQJ6V2tcjYI2CKotWTsePXr6b1jrWJWU4QkZpxDUgbxPIjFRCgli3a2t/UJtra2pWk4W+ar3/uoBoRiRlqOKubZJ/Aj2qFjD39PI2uQq2ucE22OlATuJc1EudzVsvzoeVtKMaml2TmOZJbRNC7sNTKQUyJ82iilyCUu0dZ9f+819zrfr/rZNP826xXcdqEMcPJRuLqPvSXJkAu4zqF1Glutfr6/IE0ep0ES4yJRSokRSPqLIdkOyGhFhfo8/E8YmiqqU1qAc8Ru8LjWUAXDtmTd0aTGABr8XBO/oQeC0AZROhD3h8wdtXn88c9Y4abEvXIykU4cKUDZo0nIcoGzs5WpTaSd0sOD6TOvQQwTmOc5zHwUZVqOGDSb46HpJP8w7gs+jhTbh1t1z6T7O6TzeZ6GPdi3EvozlbSEQ2io2jzFa1ULAn3Bt3GRu0DvQXOR1gS+YE7USeYEekFqgsXXIrQn3iOxFaFS8gW57CilX2PYc6TZU/gxg/fBDzg64Q7oKkFM/oGlRTkZ+x8qtq79dU92go9922JpAjMV7JGvOBCAc8AKXURAWYTqG3g5oXuVpzoUzVlmowz611VmFLDqE+ns7YWtGP59HUqSKrf1pGxt1cAKgppUS9SHUJpsmc0ETfhvEfzv2pd5iVKNMsdG4jx5q7xcr/r8TcglWqJawCzuadm9gzgs4jKJAhiQrhk+e8PpcTLyAyA1wWAc/U83Y2LWRTuoxZFhWchtBrueadLnabXZBxNHM6QubkzmiwUEDIOTxKBkLOCQQMg5LovlcRMTw8Ho6FhnJ8BfYKY70JXoVdsUZJAjMiBlQZ1GgiLUDqskfWyBYV1QLiVktYlOBSZAnC6DQDZI6O8o0dnWKQ7OpbvqsKr0YWIyo3UYwR1BaAoq23vodNxdTChFt1H06mAXVQNhZRj9GzJPNB1VVV3yBY275oB183/64KdbrComAsgYL8ROeQiznAj478wQd43d/X+//nbiPKB0CeSWsWXDrTRbbIOexkBk68Po0ToMFUmqtKMGiTE5ecAVw1/O+9U8LbmYGOGgESgKynTiiGOjLRt0PZ2wtuQDKRl/bULJ3fPpY8XS7fc5vfvHEpvOapMb/l2K1Yi8RjL6sTeq5oWfC9kaG8gkbGaXQvZfA5upn9tpRuosiyPg8rRfzYcnpTksNbYg2uCzQ7NanIh0WZM+O75oN+576IobzIEswZwMIaDzOIhPT+ZoOJ4Gx/o+B3H393sTieG8PP2ihDA0UK1gwFTaAbJuFr6Xh5X2dz4vp955db+v+m1ee19yoGhyAvrugwrqMW1TlDeSSfVvZTYcLGnnDBjAXWc+FJN8ri4nv9D0vA7TyHxrQuzcu6N8hvNOBK9p815va80XL/60c2cyFFoApCXZ/C86xhUbmsYlp/UZt4u499k7MNR8Vog0Noe+DK4M80YzB+nU21q+RxEdrrbQGpwIVdWGNVl9GRIUXgwgDYBoYUZBOniwtLY5uuq55ss/ZWt++y+vXa0xMdLpciEupbzHdzNav18C32+Xf8PV79D6PqerU9jmtZayw7fSm6+aqwGz/o80A4urvOP52fV1emNsYMBtDYt73lfpy9CRcjf8njenyaD0VFkAYBjwhwtWbI2MJtipQ1UTjRr4SabG5R2SEFykjJHPOIGQPHoIGQ5Rcp9piJmctTQ8i90+RyJWCZAToODASpieXT84WR0xFNWErLvd/EtcN3Gu8Tr8jBxsLma+O1eQ9NRvKWledHF1cbo4+lkc7J7mVn5fn5nV0uh1ej1ehRdLZpTC3kV0ggBTzDEbIgtmRgM1K2YBChDcgef9fpe7ZusOB3fbrF0Ob283ulWFgKVRdjT1eKywEW2Cb4QWEEwxmADOWJLkiTwodTeIlixYrM4M2xYb4zxnjxoKMBstd3UkzfbaZPFZiDG+ohkSoEOjwb//7+Ex+19r2f+Wz9AL2xrebzgGoxwNgCwpWjNCKW05S0lAIZxmcfj4skrsjSF3DzlC+CnqYcD8KO8Lyw9ewiG/vI4vkgomT3WHmQGZDmczmbCNkIOwodeGgp1bJ68MtwLuVZtSj8vjfTtgSyiZmLLYfotPn7AbVWwvudig0M9+zdjYixydjY2NjL2NiY6Wzs7KPODUeIO3c4iIqzl6LNPYzO9eYIF+7THOe3+z+HuYzTTRzrQdQTW3duS/uu1goq+C+1KyOAjvUbpHj9jLsq7OqYcdspZaSp/1HENvcFky0spZBchzhgMzMWKt350qFaswZoKlRhvTCMMGxC9evXm7Rnvc7cv0OdxSPaI0IQiC6YZ2YFM69d2y5HCPB6nU8RlKp1arkAOYLjLDU5VtVJ0k8n7XKSsrkpze87Tkdc8leSBF6fu3v732psJ09eHtMHK/Xta6e/KF9inxt/AU5PeYKXeKp16nYGb/RyabP6sCHHYcnrB37GOTrSJDcRQRoSMewwEBclJpHTHyVPx6D//3kWq+GNXmkylicAJKh8CUfaTY+HlIBjBPWf5JMMon9TARYqXbdFLvE9Kelt9cFwsrX/U9X7BuyPT1UU4ORoBSYasQPHmHNbJkworQCLUo/oZvAb5FypMYcR/HtlBQizsIeio43Yg2Dk/9SGDwf3TTedUyL9QiKMPh1pnor9c0lja8zTxkRcvkHReNpyJ6Gkag+HroavE4c48+Ka40Ms/rPT5DkN9jyJvYU/JyZpyJpPOzyb7R6/5rvgcD+hn03o1AlyVf0OkKP0d4fS+7J4/jqVUjpW85gVtVYoLgxKmCb2X+FSa+6+4gF7+aBWxbNecDT+4L5CW01gfMjTPUKyD0iBUYN6/7wayKAMKu0kVBFBGDR9IwPm0kIQYE0Aubrghj5U8FBIdkzcYsB0+Hl2/q/2hHSf2iWl8RiPxGwjT91mEbBq6s0KstTPFeAZQsgGj/l0ERPRMRY3zDl7fzfJ83BAMOv5SSJ+N9KYBMP4D/vu/150Y1kSMNowIpGyw9/vK2rSPExTabNxbSU5OpwXx1fygk8hh/bYVWBXu84uPDp9TiJqPQ47lXcYmsiuXM1S9proQNGQIxQxIlnQkmZEVCiV7ihA8REIqFEoVgjaO2Vy0xrFcuxgNuKx2UNOrZ2HhAyglHaxvr+0Kl8UsEGz6+hSw7wobAodGLBTj5iXD900EX6jwIMfiJL4qhsIktL4A/OnChS61qOyIpDU4H0mIfqfnyZMlzD+5b7fxuv8S8B8ctUA8SEc30v0+zie3C+1hnEeLDieC/Rpkx6XumCCBFXmBeeYcowhvqWqUCXie+ohX1S2YL3SAQj6xSabXvoDawtTwDB+VVz4kvXA3ghhSd8Dd/JoQ9tSXLsmYRMwhDG8TO9KtTVl74KLqx89I4GCycxEZL94qOYm5q/nEqJm1GHZQvctua7EFq9uix7Szwcrr3WPgdhx2u125rjdnY3vV0eBRg0tWqgaXNR8j8HXpwklrod8rVZOhYmMSdYc4NbkoCBzgp44ApzFKUZ6OrtHXs/EtQY4mFlgY4CTGyhDmvb8gDlBvyxFkCgHaIDACftrMWFqBaooWyWfFXz65MNAGi0xgreQ1mK9TEv2xdRe2l8vy6+v0meSpNnk8nk8mvxrF5N+7fqKsNMzFfdQcGldR693rNUYTBhImEOYU9PT0+hEQynQiUogDQNhgiDQ54tBo0BHImS25fn19ap5NSchmpqPNSSnFrNeLn7V1LsbyDUGaEWnyPr0PquvegQNT32VMb1t2I+OlmHzc6quePJUFYFi8MIy5PDJ0fhs/3aHr3KDMzM3AQgVVIBcfL+dyyCXb9+CxH4wc1qOXrinyDqOQ6jUDJPJXHIj+f+fyuU097FkS9T9R0MpkZCHEfPH5yumkBQBXfrcjjbs6qD2dXm+LIk0aVB69evXr169evXr3HuLCrqhaWeHh4eG9evXr169evXs1NY+Pj3L17Y/WoawCO5/3LQqQwvDCpMMkwrjBuYOTB0agp6s1FWQRqKLikeSwMB65G0qJ8fLVq3AeF5Z84GSbOuZCqmuXcLmAGh/UR5yl+cx/lmMVKNll2Ozls7jwez42x4UFmlVIDcT4Dsnb5h+/kQHjmABya0JhFJ++dPaQTEYBd50IqDBuBfZJsguxhdOMT8GKYsQpEiiDOmR5oEnPEuQPZVeunMHxPCyeYn2eN3NikTyRKZHKyZKWjrO/L936abUF3mIGNcCTRk9y5G5G4Rt4uUmyiaxvt7mrs/Sc/gqkzgh0/F3OX3x0u25eu3q460WlNi8uHLhoi3OrL/ZCM/3cDsnuS98/GLHPeFj6revqcHBwcGEazEPb19ho7vvsOzAsyKBJIcAyLn3Lkz1mMpK7Beot6dg+C+hpDjRvPN3ZyGQwTTRBwXulVgJU1ItqLb3zcZOt4+asiPxgIAIgJYig2cpLWM36yvMQPE/XxtfWbdUhBmZjHAP4se4l2ra1sjWWtg2WFQpuAXWG860SYWzkxykL5V/4rcX7BAi3Tg7g4fDIAehds0HJJSuPyiARMEoU7TAjoBfI4wg279dAZoBoCDMICgnTVV5mX4v14I1pJjP9xOw/NyTDvWc1rxWj9T9WB4OzuL1rfacHdfO3sRtuxIG8G99Bkyf4ODl2C0guXXru+dE7Rdk7RnMw6SLC/dlfyqDsr//JB2WBgIEWBCubnj3BbwDrdPd9TkgAdaPWteblMJdrbzK2jMynAJM4ogtBd9FKe4NR08tKtWRgwYPUSLNY/MteazgCdHHndvptRWVZHMk9NqnXqBJN+9QwdhCAxwpRwonjhPh4eHh6XShxjilGmGZyAjNQ7rP0VZwDWFp4qdO/y5TEEDLTGvhY3zAGs7C+Avv7/jULwssjrgS9EiAU2ce2COt5vvvyUCqvcgXwXwYo9gMoAMAdazIyxEIxER+QfWMZ2/25mCggPzEMqO1je38Nb+L/17K4DnsQYdFb8Kg6YGBJEpKUk5GHx8X/jRAWgwVEtyocccGCBgxUlh1ijhJgwcwDtX5zznQOx7WZlb03bpAdEOwpyui9tWOLvsFg8eL7rJgFzqPrE+KaDNch4RBBBBCw0IFCNOoNAnI9CmRRNi6ieFRBzRBmRiJARdourqm/xes3XsI8vILqruj5xxMJFItH9xYPAdfqSyfKJXv8DAwMBI06Rk4MxAjVb4sqKq61tyAWlP0fY/nJpkwvGByZAB8kUHX7k9rXsM+NLvM9NjY7QrOlZvvqs688+k4kLX9IMp5cGaaJgytGB3FGdEOL6phhOVIFQ8IO+DgAEcYKVcXiIEsIybou7dejlfw5YBJUW8bQy+sSFJm11kDI/PrTtgjKTJEgGIHugB8ZyUg+wMJvKyo31vqWtrWzMw+ioKEfzkYb6l4NuINmoKSe+08g+12kvz7SH5m/OxBd8t3jIAReVyuBKUp5UJYkoF6KA4LVhNHAjgx7PDz8XH9oxgfOsxBHzzc7v38/P8c3oRCBQBjAcYN8Ss7TX4V5QAg7K/+kF94Ijdbge5mR8uuGPz6fr/U5ybiQHCZLOFfmwIZefBMvRsCOoMZSZBmAzZVz9F2cPV1UnCqs2Zsglkjd628oJ/HD8I6lmq+g3MXhu7y3hLlxYiv1pjjzFHMCXnedO9DoTHQLrEAMO1c72quq2pUdbrafWHh61uAM/PE/ig2fywKnQ6LhOKFteY+7t02CBSGo6KDCYi5Bjjp4/NghtguQSQQsrJAJEuNMOgjVPicQdDVtYeJT4V9C2CsjlBw3weRAPDv4T8vHDpAwGCp224gjwQJQ5oMIgIkqg+zBKt2fXCrCuTeLVCBOdUuvlSFmjtqlQBzArLhnB3ss5fIwEuXgwx2jejXxWS+cTf1ODvK9qXcWsdGxY57fimnzPg6hmEpSmDqHkAbCnFoq5vaoi+hcH0Ly5NBOLwyShCQpxYAAZpNHODwuNw5ScLIwR4AXdjaF5n7CBYl0O/6ff9SdKumlTC8dSoXdrR0bNmy9rozYWjLdsINWmCg1GNhihhJcu3ryTCBbGwBsWfsRrogzMzBvJAy8TjL1L5cs2rxX8Qg970IVi6jELejkM1RnKYlqahDagCoAwCKYGNMCoHjUPMpAEOhcIAOUsoCAQZgWVxOfvnUx6353O9hratKlAJ4b5BF4PsNba8ZCNWQhEnmZ/XvhseMYf+MYgeEcHwu6e7j1biYwRPzLb23r1KUpUGzErxiioomFAy8S2qBaAl5puytVDlFQQQi9z+JS9iq8cgPTDq6E3DAerXuX2QPzwPBA9iSxFKMmoGPNoDjG4eaIeTlZP9suCA6noJFAyKWRbe3tkG23tgbf4na1XQ27uc5AdI+DARtGy4fcs8kB8zjbpBAj7ppPhg7OSQo49Wgz5bNPNAt5UANA0CnX2E7eua3OIEt1WrUs58oAFDDUD2UdvBaOmHD2BUpvA8cgr8TnN7Hd5tngYr+POP38Psezpt5en3KagcFsi7zsHfBfkAzGLX2X1h91rJwzwxA4QTHT4mokTAOTK2lI43xeevpbZAK8Aby0kHaULWtIXO8Y2z29vbSQaAT2sprhcX7ztzuauypzdwn/S74EBVXE6yEkmNrXhd77Vc1thCBlrwvXr21tNBjcPlQyZULOhfX2tqKqqcDV1dXV2cV4G01q6urq6tc4xnFZiONXW4XC3s73h2O9IvZydlLCqrTmMTgAY2o3ML/GxwKy7/srsF68rUjknS4qXYcBdhBb7fBeB7FAqa1OBuuZLq2oQ5fa3gOI6XMgMOWE2e1nCvt17euzteGC9EGDBgsA2V2QeybfmHOnm7Pmvc9ZqUp2qjCEfISwRwQGHpU2VsZG+UxoQBfrIV+TlW6Y13J0d1IMYc7+jLpImN61Q1/KmMANGVDwyozw2OaTNkGTHQJBDGTJkUU6nIX3bskEJxju5Tt959YW2gOKEiUAYXNIOC0dPnyoyvULW8COvhjA8Q2An3bviX8IBzxKCGG9m2jFq1U5EIp0OBPZ/ZjaaNXYpcZWZgAwjUiSLAyUXEPw+L9eHGB/U/FfzrY51RrewRz5obvS8HW/nSRlo6LqeAoXD9zja5eoBcysWuFXxo7IyqaA3G2u7ydbd22nAFw/Y8rYl1Z0EPSaVbVjS0o2jysvLtLDLxNSP40rWZcS/N2VvJ2kdOQKSi4TWKiOkDHODECYSx4uv5PK4c6koHm6+Q0qc2ddZcwuP0IHQ5EFQNsKoVa1Te6O+xVqOxBD3JItUYOP1cYhygXJvr5XGjql7p/z/eqdZRaQgwZBscE4Bvnf3ev7vcvVlDKpFA+H6gedeSazGgUrFK8mD7HTox4lMqZKTvpzAOui9TV1dXITNw6u4OVsLAbM5OTljy+/wZqytrGvr7WQojGAotdMuYSEEDF2LOPj3FlVUV8lZdSpyYfkvFSXAdr2LDikHID01wF2b3CRvRdLQ1d694Hndwb7+WvXQ7CcEYSMPdR5HurjIH6UFOHUP8PHxlyGYYQagFQ2MHPjkSyHVyIDY8De5Ngl+zVm953nAfIuR5r/bkJEDKzc2/7rIZd5+bjKqx5cXy/Q8pXocny0lAAyAiBQS3qAcBPENRy/5nb4ivY9FszUcY/GbHDQ5oAVsmTQu26nQb6mYBoQZNf8okx8DM3JENw2AbZBSBPdw9Lq8zP7nj4L2QzQbWHw/mz+jsVtkpSkIcqVGuCRkUrLgBpVghK+1Uqw+pQiGYnQSI6BOU3AcSxh9MADW4Yt49BPRvJIApWEZ2r1ut2MTWhF0AZAfJmgnK5bJbjmVONxqlunbiNqDQ08/L5e8v4/MkxaZ87ucjbAKv6thGMwCyEm8k6mRSwG5hSudb/aShtPJyRRq/iv/pb0NQNZPcr5tmA4uEEISFjCYAYY75LpUYiAIjM+mGbUECJqpYscPV6DvyKcO3o4XTPJVfWIbpjUalep66LiB5f7+mla0VrXwfda3zGta1jHMWta2J9/3GWk32cb1r5BsSKOCPd+AgO8x6L32uMPMyMDJDMAEuZGQe8vP66DM6PQ35dfpt3Di4lLsIQog4Blp9waNoI52x5lHAsALqBxwkDRrguGwDq44B0Ll3V6eVIU2SN5A4EwaiNnZnifskJgKDC0bLtttfNcVvA8CHtgG+WMzMT0IM0mlEBQ0BBhO9dG0oIE1AQiO0BU3KFmuZs1zb89r5IC1ECmA20tldQ2CnBlVVMcuEkpBbWBB8IOb1Pg8nu/ENJpxz4MerXKwHgeBz+XLooWlTqK6BQaCvMK8DtQvAs2An0cfO7va1sQSO9BgkfZhA9yAwGECBAGB1AiHfBnhMAqNvX6VMKYUwYQDeAwgDCIZwYfUhpCwYAsAgXCBAYWCwUFBYIGAUFwoGFBAoIDCgoGBAMAuFAw0AK4XDgh2+zgHP7O2awbsJghhbu9+aswGZkg9Ghv+7p0EN7U0q63w0fFZZwGO6OoHYz508xEJYBb0XULW9pbybkgBGjnwwuHuJVJUgNNFLBkkMPD4+OhBJRJ8DyPn/HlWjPUpBBjkRDRsbbQ7bQ1l8HEYG4C5QFSswrCz5ZDmcWEU5gQDwZ5DaYCNnvOyRb3WdTyqmxDH2SNtWszNtpt9pNlb3P7jzJo3cV+76+j2AGxqb+Or8i1dwFlVKNyciksNv2GDYhNpsQueAVVigMPW9xgfI+F8j1r3pdh0r/NSV31dbc2xCloKmiqD/uErtut7TNbjAHZBgjzg8rpUCOKEgQAygPN83xOtb+QeoUwjcsZEFAixQ4fCl6BJAGhAWy5d0h1Y5F9/+7KBI4WrWWMrwOriPZm8xoja/FSqocFsgwM/xPAxrvdbogka0ynqYGIXcLpsUDOq+l959ZO0sjg7YqRDf9fcdXq5vGs0tvVthJAaQ4Z9yvPhTiJ1EbXJD3/T83G07ytSD6AcfU5gVuPwwnsjY2pGwaMiITVDsXFsmjicsM6rnCzpvZonzg7apINsY28F4YO0bDp9xttr5+3hUvmGjTopc7i1e14IWNS1CrXBUAq4JgBAGAwYJgwuDAKAYCgMKBgKgYMGDBgwYCgDBDBgePTnDpWIKh0mm2Ihu6K4/bVEy7pq07HY7HK7G94m34nwtTT0hLnM6dtcOAYONwWd3aun0aXF2WhRoaFUqtYDINMY2EomMYttGQYVmtV1Q4OBdCq+4z/u8TOCz3FXLjl4MBfNDV6/kYcgUuJRT7ENoG0AW2AlAgAwIhnhKEofLDnhTnpZN3IscPMIgT5ABkQf3eLLu6su3wUG4FaN2OxfaPt3nM43mMQwY3jAUuXL1+XwYHLW82v4AFLzn56vpxCUMjMwQWqJJEWMkGZcVbGGvtlMC/76mXRJuRbTwT2ve3lihttt20zahoM3Mvzt/Jly8GbAYcwevj6sNJ3pq95578cCi9dAObmLDdxzRPqGogoO0PrRjGMYzAxbY2xg+6gSExjFQURypBgm6dNBQ6hBEY2EajjRPDiI1Q2DbbjJUpttjYDY2kMdnao23UjY22222MY22mMbGxsbbGxsbbG23TbbbbdSUnUiQNNtFgDntNtNIR32/UkkkkkkkkkkkkkxqrSWkkkkkktVSSSSRupJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJCkpUaS1NTU4D2PaZgUgluJr7TT4evl6+vbnYBeiYAwHpLSCWMma7mWz+D/ZqNurnihuA4IBoYOLE5HM4lCSzftWphwBn7jYYIQK/+PW3gbngVqxnMNTTLcbUY3t7APmuoUyjSwu2rEJPfBWhOSMXAJEfl8azYwryjkgG1BxoPGmW79BbjcbW4zYBssjE9s9HAt3DOGvEqCROaFQgJMgUdN2ADwAMAMdEDR6PHPDDdXlQqAGYHjh51rTLahODbTbbFUzeJKrPbZEW2FEMmBpXxomAjR8bS12lT/Rqd0GBqKf4d7/7k2dyk2022Xg5gNBoO7e63E324UYVL5UUWJ5N1CqVDlBHZE2h8SnLIoCsbTemKmJZjXbulwqpd3tRzqWt7BvPXFgFzTcniYc42imOws1agoJkB61wbv6yL34ElPiwui1gb61Wmq1YCGLKs6nkzLEbQ1PzIUPRuBwMUNK/RJo6OaaMnr5walmvYaxRkSLg2rzabX6/nfCjfYFPDaLdVGjW29iu+Rm0igUjPDYCiDZr6Sx9jibXiy3G0xjEPNm05/T9d9V+z+N1vU9/6GOk0rr6xtjLIsxQih130M429LPlpOk1w4EECpiaNCK9H4V/EaYxgp9DR2po4oaZZ0NsUs4PdVtJGlNw9PU3Fy+dJwbhCCbZfvr4AStYFVr/zGck0so5pxOki8pfapUQd+06kqEzWMHDSAROgWvJtsM02wY2lts3gV9rl72lsQKyNnahZE2gbJ49Pp8rp+JnbPZqtRnVaqvIIRXTa81Le8eW4yfACAmMVAkBnyEXrenfAeE8r3/xLf+I2Emg/Ehm0xwCFWUEPg+BmDMrVm3u85KsY/GrwwwiFOAZ1bEmsRhnbGiIiRogxstNCOFwsThTZLYmmmgbU0fcY3s8Ppay3xvL4/l1a1sLm1cJBCbkZF08XtzqW7jqzIGJI+87+lzPxob3fNEBoabAJnR1+uXtTYsX76/E+APnQ9F8CkA0svFjOOhBAzmmxYTEIKmQWMAh3DDqvxunFntO0fxtWLO+40TUk7ji4UrNIM9aNcRBe8vgdssDi9yr9+/fv2okGI6pkQYAWfKAsJgAlH6iSt57YXU1bjIBIEVVAQYg/FVqNiDwwklmZFak2bL6ipZsWB+naW7Q9tCtAXnd/c1gMItiO1Yte0sfqanryIolhiP07UCpn4+e5IeHm5EvYgBmJoChswQcGCBb7bwq3Iu43r51ecXr16peqvHoF2CkEQuBsAxg2DQj0WkEDdgj6Xkm6wygHwQA6IdyCXkBvA8oLYRrAwKZs6gGur9xqeVw+eYId0eJvbrPwA/LPRPBQfmppP0x/JD5QiofNqBjxFSpwgg+Mv+gi+kRBFsUagPMIpaVj+5M3y88mgljUS1ifgCDJUlgGcXvMgAHcqFbZor5SUrqbUoEODfGHgv36m1wcaenjcYcD6yAZMkCIiBq079BJAJEanICv6hweD6a9FVw4VzEZpF4LVg+EWT7NqoJlD0psChO3t7ey7NFsQC4FH4LrM7TjF4hr87LttoBYQsMBFu1sgJEmSn9o1PqrdsXJvBEErw8t92z7HSdCOAtqBAuMFmMEzBcnA5IArGMNNQ5BXVyMGDNzyMiZu3j4FvD1Htk3bioAaGDF3RK9XzkQW4o3w4+YAA18buoHjQjPz9EvQ5A7CbYIkgTzIFrfkayHQZDjoG9GK3oRFRt9zGsBfRc5vn57jIKgSwgiaFFzqgg9BFAZAt3oGYBeBhCN+F0LsxGDyDBYtnzgC6wCcftnkhJnwLtGpwwQyDJWxljGODyWP8WrIYgHSddCDNCEBzBtautqYuK9ZfG2KjgHYmtLkZggYe4OKZlmRKZKylbqpbAMwSjIlcEZ9AjuAule5VGZsREl0BTz8KCkofKJjWoM75wji2BsMdEDbGX6QYB1QqBpEWF6oRq8/r8DACqY+2LW8JQ1LrtSzYDt9K74ive5C4LlGQlehlB7kGjqB7CMhhr1rIqnbUoSB3YXqWMXaFPcmwKVxTiJq6xqBjFBi1QJa+Vuco1gjkxN11K2rs4cf/9+R8Te6oXtk2cIG523YX0uXfRQsdo03nGMEiFU1qFloVfivUKbRZDdUkL0sPc4JcpU7QcHKALVLJUo7qelrZ+J7/p+8pgVJ4Kdg2ns9nqwVQ3tjPJErQyBXFk5edvivP73O0L1hGX7ZFPAZbWWQZpfAYWgmoWUKIuFCBDfxpgF3ErvqrjIeXBO8v3JRBD1oAIIWTS9rpTWz7r3GExYyj4vRIrI/IXrYSGN0V8zmM7UxrWs26S1lZL01Nra2vZfU/oed1BvfAitcAQkVpYQhKUpe+ilKUfLWQoFgr1FJCzP1l5KeohEjL5thtQy/mrp1EI62dK71/KZtjeEePfSjuchi+BzU58Rrc5nRJ1b/q8zd9Fp/xIf5IWlKYRei05hFcSaVN5SZ35/Pklgakadtzxwup1fkv82FaUr2DUnhNRdLQTq0FMGMcwfM7ZuK16/TZ53sfO+ie3EjFufzouRnlCKBFnsNbh3d4RZv0pktytOZnwIoN6mMuo2QBjgGMb26s4QCxdMp1ZiMlN2LfBxdnm1Teoq6nABjxturCGz0QBsBCpsBBAYIBsGwB2VXsiOrzN2kxFqQ8TxJa/e+J2x3weGg3QZoip2tzxo7uwAwYhny7YWfj1g88R6u/0xE5TAweaVUlBFL8fk/H0PT0vUf9mD+tFsV7GApHwAQD/yUAYiEB0F0yoI00YgaNMbU1OnGPSevXv/kBqB0PH9RDYegT9m+nfUGgk5aiQPBnA3xGfay2hQthcE6KBy+07L7rOrpq8gJe/2VZUIDgeAyFfH+v+P2bB2e9EeCI8taLXD0O7+L6XpelSpCGI43i6Hr8ia8DBaLgNB4UFHewMJtkDMvzrIakWTJjpX/9kypgGAeV6qWWbNm1MuUBhuZm/QgyhjFh7b1kgctTuBDluA7MikGtnszVk1oj4Ilk0+xEepTzLuvYJVq0t4AccqhvO0+ZWEZIg4pcOtv47+7Lodxg7JTS8OKkAqMX/aOMmowxqM0D81m7kJhMaD4+OI1mNVsCMMJcIIhq0oU+j7W4sawRd8zc/PCwKzmV/rfZ+n9jzqXmzi8Hm9xjkszKCGAWtI+IB3iEa8L/72iVPcPMBNbt2cjJb5nlvQliACXzDvVrLqyLTpYHYBgcxUoJh5XTDnQuEsHOEUkFMLPSY0uxYU0EIoaJqKVnhQ4NABUDiDKBoGCSgRcCYokQSn/z7OtmZva8hecEKYpbG6eD6n6Ot/Vy/sVPjM6kpROqpqUoNKVLa1i1Ja1jVwZKE4LUtjGMjVOqqU6qpzjFjWNXBzYOdCEYxnOqpUmVRhKjFwi9z3PlSNVVKo1CNU5Ti1TFTnObYg2xBviIRShDGg2NBsaGtSaF1VKZVVCLosbGJsUli20lGEaTqqeKBokKqjqqNKGta1rGNapq2ra19VVVVVKp0qnSTZPzs6syrT0vQ4e575g8Z3X6/Y3AJk0EZluQRDPsLYCNip7EpaiJdPp9Ofk0/S1+GxIzlMVcQCcUpAL/k8LdhoBsw0ezreGJVQrFeTAWC9rb1rT48q76UehkyelDd91TSs8fYA2deNIx9PZ54+p9B5LVvgJqm+NBrwUh7+XACoMzOB79BBJrLBy9VQDnyc1syQwvU4aT/NatuyNJ2UCMM6YSlAjDSNMkULRUxPNAlQI20mwcgRzMEVNOqVKoDifMgRpjTzwIwbTGmwbBsGwbBsHIEYNg2DYNg2DYNg2DYNg2DYNg2DaGwbBsGwbBsGwbCzM7wZYTMw0jCg5/dPo6GT7t5GUq7qvugO6hFmBY7g/d9fXHSIYqW18C6ia2uI1fKv7IO/3zyuiHKf0c22s0n3FfFSt3DIhuJNiFyrCHmG0I57Ksi9zB3eEwEgwwha11dtoGxjbBMGDQwGNItjRg1ZDbwrAiBuITjSkeIJQwxd5aXpIvVQYylVUAU2mMSboZSAYXKAiZGRlrVTFHVVBqgTVFwE2KohtjTTAm+33XA8LgdjboQSS4hFo1y2ScIMTVQta2Fwbbr1sf6nuKvkb3oBTJsxqzVRqrOHwakWeJnAz55dHPWRnGf8LbOAw6dlJTJQkKGJWbR0Om8HBXKEcC5GQBhKEYKIbw+sXwbJLloubf4AMLaAbt5jZuBgUGdmH6oGJtRGLBiZMiWNHC4uYMOFQKM5a4EEIwksJEQwRHEC7Qr0wieGBigyAiZFfRlDdyIF/8qn4Lki84xLXbPO3jUUDbMXEnPgn85lxJcU2Oo7WUVFqE/AGDLlAy5ZauXUa5gpm/xcZgHTo0oQzQhDynoSoFBdwIwVPKNMWHIfs1bjOKEgQ+mE6iKWBtJU6fEeZ/+NjLlMJPOCprqoWAYILACHWYAellie17WaKo/gDMpJzZMubz7JBbLPYS2cXhIBFEBhGAXpgaLvQHxMBNkHO+33sMklgMa0YUbGiAWQUGWho9DrDll53dHh4XFoV4LyeVLWf8v2T/iUhmCVH53e878/xu/1S35fiXxxjY3B7eW0i4Vp4fcwml800nQDpKmvnfJduw7P8zsCYjla/NxP9f4JV3/v8vrow36f0zLGi/89FRGT52X8v6fReNPk/jpwa7bC7Rff1yG1a2OEwrZd7AuOJy/1uubd4Bu3566sPoctO45hkKaxdx02GOkwzkv4p6Bl4A8/dxkOi93c9g7qUUzd47KLs3ig88SQbYIFy7DuDtCq9JgvZHHwSsKyRx0cWXYfCnThAnM3wYM0WmbL/o7XZC2fjJheDRpSQ8z9yb8PkftNIm6WZp89ZCr+mjOO89FrF0bk7lPK8nswBRw7IE/93D7jdpKSSF44+RkZNKEGUnFaiJ6GAumoELxrO4xfgqIlqaCW5ZEtawS78GtINa0glzcLVYm2QQmbIIeQXRLloUZLIW/UYoLc3YoA8E9y9s95vU4BwKj33u324WDiDiLkgJApy7n0XhxBoFjVe8g/fOd/gINYQzm33WrVUXEG2Ut001qQdCQYrw2CFgdWRCzPoOpkx0gLmoRb6hCivpLBdxlolqBUXcZcbcOwb3gnN1hrbT0nFm7IhVm/nfSvax3iGLZhAg97srK+NOkwLgE5zmQZOf8KmevEPEOQEYxIZmfOf+UTtdGVqYE7EilX+mOdrQBZX24gW9u/7Ye+zZESFmUo6H4uJ9uWyG/nMTADTxqBFBSl21YZSUhi/prBSkM8TwzlKUhAENeIjB4GGqMXgg51hzcmXU3fSgRXTunGOpp7r8kEOFqjj8ccfXtWrWzsEVixbqpIpDl685zuUoRUpOcikKtec5xBSllhPF1NljFlWbMHEVcYgRdC7thBe8qHifyKUAE5gWZzmJxEYQAEIAQhCAgICDwT3gThB4e8PeGmQqPJPMAOUgJfP4krDREwTnAOdnOmO/c8wUgIQAhCENy55kTnAOc2A8bx3WTsnQCMQJX573pM134Hh6XOILoKfgMJsw9D1cDpDq8sdNYJ7cwq96pd07o5yLt55B7srg9At28RcQd/ac5xObnOJzbRdQPeT4wEoAQa0m6TrJveg7G+iI+3sqFzvjv8BxO/vuzp5uS0m3pFsbBXtOAqPlRjHxtGGKXRfhPCDkcoFCFiqBY1gsbhDjSpiUoBSk5lOchDvIQAhVCBQgVURGMYjzfJpzZzKcynMWbZ1Hh1bGZYKx2qUKhUF+EIQEMuEBCAFji97KUpFLsykJCQEpUjAeL18brwgUIXCvHeMSiBH2XAO5TRU0BrWgNa1p7JwDsbVeA97nl4zyWAvWYwhusxYC9ZZDF02LJY8ZhBnPQAji3pXjWBs+Czg2CMHeB6zKsrRhsSB0RHy4Bpep7bNjmZh2z05gB+Nblz/pUc7ioYMmVDoYWN+Yx7EUmY1WjyHKBmNMP1lKdeV/Jqxnv8cSzliyRrBqLphOHlmxZHiSZUR4SfTov/D+XntaKtZLVR+sok+0gIrykknmbrBAYNryrmL8F2Xj4vYbHm15Du1k4krmRE2jiYUHdoLt3xUhRhRoMIPEaFY6FDmGhiHPUIM23NU1JKxtJn65VmPI6GVqqPJzZ2ecaHYP/nurAUaW+fwLGzs4eRe5e+5axa1UVVUVVUVVUVX9+1i1qxta1rWrC1rc6qqiqrNb0PbePjjjtVVSzqpG4/LqJsu445YmyzO6dPHC2afmbX5/38+Z8b5/q+H/hz6D1NZfKprjgg7STSPCB+r4YjNy1KNVUiJGaPKwKnW2BfgB+/QXukAeP6OlfzSv9+r8kPJms9iSPEqamrKndycH4ur+B4h8wOSHl3Eb5qdM/O1rZGqQjkAh7774qRO+j9rLN8LrgZHyx5lLVscjc40ERCZ9jhKPSBg2moKlHxPvQR3LoNABeqXgL167ewI+78YfzOlMIDgOhURdT5yEMukztkRM6/9z8M7StpMVO/61R0W9I3HHcXJkbvM979Tot61m4lBWMrj9fT+xG/feWW2mGOI9m1Y4haqJZ2cjODcZ9PhbfQ/R/BV24WYNttj7F697fPhweX6alYNGGDsHZNW+/pa+KsQH6Peu72QQD6n8QAxXzebqRW30ppCJmvT0OTyftfj/p41PJ0tref7e+spYLbmtwbbS2jV1GAF20otIIuDBtAotQYDai0KDQvb1O1+zT/3afcUj7r632Yc71sqYgHddoZrcsUd6RzlKxRh7afQjvFbqoYHQRSTJ1ClUrcpk6dtpx/E39Lx66PjDov/6W0JkJAO1LU49OyYJgTM2Dmx6BiTGiMlorRC6FFgs0VUoD9jRxwO5ZU12zdM/ueRG4wAhfd5HWH4f3+UBIKYDJcE4rCc6syikpV5S0JUGKuKPRyMrJZJej8O9DoZsCzc0g/FQumVlW6WwlAfCl/gRFp7K6XILVfltenM/UPbnongOyfYOs9weE+wePk5NrC/Rw3hiNxWchuJW12NOgD0yyAEBj88My4aeSJZS7bU1vCVxcFwXmaW/2ZY3PVkyYUF87R4mng8Ns6dV6nPeqq+d6sVVVXRORnMzGFCCmiOchBFNuKBtShIZSwyZzKrUWGatKhXlcx+uZikhWZVZ1feeb5HZ8mZ+PalUPT6/k++6flfOhfM+JfigNzM2hgUpqAQUMFIUy042aRHUqFTDjJMJkT1gCICHihGRXR8qpLw0LGeIp9vbU8zU1C8n/pP9vAaUTzIX/OeuYjJo68ofMpqaRpSkcqoy5fLjLJrzC+5VWnNteFnFmtd/ml/hPlRthSDKxpjDt26ZwXOwePdcfzMir43h7DZ1RK00hAFdoLDAgwTbaTahCCG13zDBweR1cGrm06O7OM+PHf4JMNDaFiRIDGMZNJEm0KzUGkDTjf2jzKm37fwKKbLNE9v485bpSnIfEpNvdrV2Vr5HGSEgqD6MIXDyxcm5JBoEEssMFOUS5o6bQiIlS5aHTjDkmzhNKuIxcJqliQJmDafw4aaI28sGdVpWM7Medj8ewssbU3xITCKapNfYiX3uzFqKCW1niNPEggLWiCSILOqiSS1DtIkFy+5QZtyISLsBJtB83x/K9K3STOo0kBOCSaHzhtjggK8RJK/ikCQXTCw1YcvECWu8eX/x/q4mGPoUg57XY3NCw7tf5SvOxgl/1BJpHtsO5hAVAeYNABAEj5MK930ulN0uDweB2HL5XDvLAu5r2mRBAa7YQXcNImaEscBMXIavOC9LPpefzDSrnkHST0dODRdAE6mitKN6Hv5p1nPAKFJxQ6dv7XuZYxm8FpBaO2Gnzfw+H5znPGMY/xfgD5PQa71alIh2lY32SQgm+LFYIs3V3V7Lx3Ld8apIwpIR3SAjmvQhJFs40/2COCUSRZABlIvqfP2nm+55DvwXUBvt7GxGdc3E8n8n2auE+Hs7mW2WOX5X+r8kbdaEnd8J/fpNfYZTnaz5PmvXrqYABrB690bGH3wwJV+EfBvnR5PmpwBR83lcGcDcvhTCTBtMRhb7BrGsgkbFH5fzj9XTX7wiJPxjnXyW3HhLL+1+JGCWBhdAXwckqaXEOOl3TIaWlWuuOogKHU1J9fs1n6+oqhxO3ivbc7cGv26IYCscehoV5jGRBn+Z5oDDPSiuIfmbzvWFsGsPy2wGt+A9IJijBxT+MBgNpAx5tYIAxQPvQc1gfTE5WVKeb6UTM9BP6jZs2TZua6gRuMwTZUTCO4plZnBQccJCQaw5QBMgUAJASzudtc12z+mt+WIewUeDLWd3ItA5JonMHIgwoT1lIBBRKP8OQb9LlELjkRFPHbr0LlmRZ2/l3vz+lD/hJOVGjdb4e8WrmnPCvZpiS+EJtDtI53O52H7EQnZ6npQPDE6g2/HNiUVZPBheDmLEeJj8TicXivwtJCBhGOsCIgUyb3P0chrptDZq6y9XpUvHANJ03mKB1afGqAGdRUVBqidxJKdhWCAO28k+mnZEhSTlG/BaFsQt5imjIDPAmRfcq+1RtbVNSqqZBClpjs0LxA4c4mHXvMR4+L7CVceJ4Vf2uNfdEMQNv7sLtTRjPnB0Tv0WMJPMPPxYixdnX8guYHSTMz+mjR0NPpXtPEm8yc0fW0jAYC7bXL1oIBsQkmxIbEhtAvyWgQY7EAiLG02Df3j7/jMYOT9k/ejVgvb/9e0zWthla1kPBopFS0E6uixdolCvlQsaC7xiHgEuEbdSWtYCzByrWbTbbbbbbbbbbbaVOr2rNn9P53V5HadDiY/ydDbc/n9CtY09LWaV3DPGxmzadbNg2JcE5fP/BpJiG+82hJhS1R4L6Olt1aVXIW1tbW1VaWlkoV8NN8Hl8ubl8a75eVne1f5tb1Zdr/FMAAcsMIq6MI+5G22NjhDHW+up1OXfqafJzdANWL2S7f/hWLSweZyYqGxVnWvQSkSSXL2ploiSBKhG6LVwvaks0mwu47um2iOmIolOU2CjUTKcobUAjqQVFSA4yqgJoplUlGinBVCMYqgRlOYVQWksNhTqkoKpTQSv6fo2FTGK0Rdo6VQVprOBWUqlGYSqqo1KoVF5FUIwtVUwcoooKo0OmN02sXV5BuSNmEvaWqR2eDKY3HZ3xl7QXh5eWfX2yeLTUmLkjz1M8uS9R0SELNQkI7uWjtTqqbhQXdO1s8s6/CkbaY7y0qiRlTFt1IN+J6Gr7r8Tz+hWnVpfFMZGkqu1Uf7QnlO258ZT4/sWcXSAchJOnenOPLKcoge+RSKenU+g18+giMYbnAjQ9hweOB29Tqt6nKkwyykrZMGnKSSMjXP9VBq4iI35vO0OtVjfmVho5cvr9XSdIc9MIESVTMgTkpNqqfz/nF4VePlWL05ERESqpWqHM0ZGD0/YyZmThwsqVOAN/PqTCjHGsOeLo1Jyp9Y4092dWaw1h1Bx5pjrTSmQPpQoVImQMiZgypwxkYsmhNiZkyZlTLGkNGfgM+aY6I0Zoz4RzZ1RsDJnXHWH0jizoz7xopWbyfhxmTiZyS77ES4GJ70tx/3E1lbyVx1LPAc6d7ejtMb72D3usPUKHsOzemcBRfMQxNfKR5bPGg4OP7/vxopbLMIpqSjRTUKiHkrnOegf7lwb+z7Tb79/v+ufoHAUOxYjO5OPKilyGjT1pk0zMzOOsyJo3JyTcn4AwYkzAOciIpyOmvBOGp07YynR0XkqrqtlpxE971vbOy/RtWrVtvbs27b+pSKlSpUqNEqNGgF+1MH8An+APZ7E6n7qyBVRxoqA4cCJ6npae0qu5S9zF4K7GqAMymrWlTL1XCntXSzplkQvMzu1tZYlYib8u38bJk+ZxsuUsuUuM0zB2gZ3aTMzM+/7R/dLQbi9/CMuXU1KfwgNRwB+z4//n36KiopOioqKhooQq/m4HLRlojneepRR5etl63sYYzre/p+O0vZbT97vNecHGjRoyjLCsZRnzjOyRnGni3s+HmICQAOCWjTU0lSj7OyoEkSYkol1oFqnLhEimoxsYPKoUMbG20EmQ7BkAXDw8NBQmXDh4eN2b4dm5Gz3tQqkSnTf/lTZ4n1JG+kJbMESIiIoDRm9qPZyzIe3xmSxWJGTQxIhLDfcPE0kMQmBG5V4AKSySi4M0XFxf74uLEXFgUA+fGiNH33bt/du6WKteVH+NGCyt220b+34t9fY/BoJ2gZ3f3gB0no1T1QxWq1YdKkVKlpZivWrBmzsf3snS5mZmdcSOvq/l267MhwK+u9+4pUqU+lSpO13Bcg/El/K2il5+T6DKvst+ZY0y+XxXXaEL4FmzUqFZstgxnKiQCCD90y/b9cxsy2zIoFMg8vLy8vavkNLvlrwFrlklgDOYYAQ2sEISSJ0E89CRvjUrOoIQ3smbAKmksMXg6GI8wvIfDWJCxgYThzYEBN9ubpWwF77PFcGZmdpCIZBGfXCRI4/n5xgNVp1uzm93kQaCMxhw1de1cDazcExwsFFlU31h8Y6ljyBueSLVpZey6zwR7qxYsAWLFixXAr151WtXfIUt2O3UwzIS9/VSFTKSkpISQk5MSiIRQO4cOG9ypYqwMHlwgMOrUtkFrk4Vlc2Tq66NcedYFesys1wK9fYori03UMzMzgbHc3bI7fas7Bm3tFCb9aJWjbPHuV6a3cdxCrT7Nmw/KFM2edWLT6/xfcNyhRdfV9CUVnmPa4Fe5YHrI9dzr2efZH0/mn74DnfkvX0wrhIDFwREqqoUhqDarbW/ak2mSwtbHK6kZn4/l8nk8mwVgrBWC2mWDAuziN3zzPrbSBZZAe4m/xbSnPXvAO/MpFdEIMzNPG0uPjaQ4lTRVHQ2+4SWeSwtQ0FKTvXO9F6dtZ0KFF4muJa4tOz2VCc1/cn5vMaV8lJzUvWkZqZqZIyXG1GEOBoy55iWNLD+ebOFqxX2rG2p3scdO3KTaeWu9+ClKqoSEj9D97rda31rYuWwjcCEGic7HwfU9IQBX29vbs2bNluLIsjw5tG7tIsCUBbtoW2FjMzMzsFdaVtfWO34XdfUt27SAZWid2itqhPyFA9Gvbe12tevra+vrs2ROLcP4Np3wVirVirFWKtWHIcAVP1aqae880cUVgmDSFU6yV+kVEozdA3xLQpUjGlJLJJQDsaur2OxDzV9exr12LI1te0+thXuGYSlmhKi3Y6bOCVzTxONeHCWxfvXrwvAXgI5ZNbYRsB4BhwrbCj9kkzPnmiOBW2fDBYxjZYcXTXxeXgIsQ3xMeec78PJtr+3ZLKtUluKEoB03MnFi8DnZMiMuFxjGXFkCcuVkFFNt3uIUaXGYZ9Uthspv77ZcWZAFnY+R8bRuaR2CatdIfjSNI0jTP/JAkgSAGAPA06UzODOEEefNkjjDjyGIN68hCOqBo352/Ct4cOG+Lk+PavW1WiFr9IXn99Yd6oTVO/wcDOaBPlb+v8fk374uXJFy5GjAdxucXgRwBh8BgwcDNRkgzMzSdkQsA4CM/aRW10Gyu3XgGDb161KnG73oWq1y4Llk2iHty4G6txYZFFC21G22822wg66sapkpaWlpaAAkOfD+h3kff9X3ffwwaZAel8m+MEfseeVkXvc3yb7yvXv/EqS9pips86G95Ke9iX7MJweS7qMLzdG69hSF8JPgURokNbSjFjFGm23SrSE7QLn8+gCIln7fV3Grq6pNp6uqUpJD1nrLWXe6ggPmgazBtESQRIGgBsCMQ2Gy0EYqYRi9+xRghtA2CQeU0jmtIAlYCbEhsENgfTfMjBzDg39cFmBBSo22CQDY3ZjkbG+8feaitTbbbY2NttttttttkvxWhQS62TLzYHH5plo/G8mfmztttulrU9oeTmyZpxdkZpIe2hIq8mx9at4/15qWZb+NeqD58KSj1/F+Z875vz69jDgwhSFdWS8QmllFqXGiKF+M1CB8nmfQABKCWACsth4NUh3ncTJVP8w3DUiBT2O8+3Vr2Ftr31asAb2YjxGk9bsRAVf5cm7+qAV4kLANN6ZaRie9vNOZtt4cIQN9TVivdxVQqVP0/kU/iv3Unle9bfadngal5xAvcXdUaL9d9PKWgzNNlCEWvr5aVj3rehlAAAWZHqxqs3X8H2HIniV6OTxI/4/XeEzYa82De+IjxaMiPjjvbEhh2ARAADixdzc29y1JlSkdBHs+3OiS+5HEdPAAAAABGr1bZ2xPiN51lmyMzMzR5E2YW8vW955Wr5qr0h49uVAXFeVL7uWE9tM1S+7ihoL0v0Hioex5EuL17shO6zj7cgNHYixYsSLEhhMVMVSLUqVH0aNfy0RUOnUl5aqk0wokkmLevYjQ1bS/Yyavt9+gBpihuiERI+PUiLFAgvDeEIP5jChjuTBFPnV6/xulZg16orNL256nqcPhfSeezYCCIPzAQYD80v6RusLK9i7EUzo2iUaVxOzbQWaFQXYIN697og0o40sWiMu7QiqVUGIpuojBiqohSRITkFJBEcdMKqAWG0kk4ypAjIwyYU1TSjUaSjjQo1Gg5DCquCFJSRGEYKNRijIxKSORJSRBSEEiphQIKgUwJIpJGEcaI0o1GKNRhGowkkakiCMIxRpEYowJG4BJCMjBRhGEcaSjCMjCMI0RxgRgowkgTwqoKYRgRgEYRhI4EaRJEL2TSFTFTEEaUYi4AMAOswSUQgYJggGCQl1mAhKCQDASAabABpJCTEAwBBydWAKI8AGL3aaHbq9939ri96NBAcwlNsUcKhTbbb7fqdTlev+XgdXKN589U33PU3dbqpSv7QiIiKzZsh1Uq6ULVariOzgfmwfRxjMeYQmlzNmmMkRkINY0e8l6XTk+THXEkSQkJSlMnjyI0eO/LfiuBFDoRQy8znd+0+ZVkPPUasupBgwYMfrnKfdJD58+b9QAEHa8uehQAzAniC8gz2cH+ldJmai4EIwSkYAxgLCztAwZECQdGzWwcHBiRIkTX5YGzyOQ+FobSwEEPKlSTJkyeKOmPpi+ILaBLsiNviRYZ9OQvIkWA4gSJDWRIkGcU5GHDI5kaNGdfnDxwA4qVa6K4mLARGQhfbXsTlWicgFJKKqhBVV5lkWYNpnKgQaG20MbYxsbbRUBi/JMuAku5+vX0y/ycnJyaWTkN5LydDU7zZW4xocqiH+SUtj8N3HpfKEeNGZDBHjx48eO4jGceOiFHzMJTFRE5Il8oEJDbY2xtjGNpjYwY02kgbfeOAIGNNgNtjAbBtppgNtNoTBNpoaTQNsEDG00hiGDYJjYmANMYDGhgDGmm2NtNANNNsYhtDYmNsbbSbTGMbTYhoTG02NobE2JpJMbG0ANiTabTY2DGDYxjY2m220m0Ng2i8iG0joRQiAAAqCQ1gx2VJczIzNpHGtw9Bce60PWuHf9laxzXc0S48kbWOTKiIdxWt79sATJitdeHK3d7Va7Mbwt738iZGjRIkR9Ch4oGTJG95/UAIyYaOEFLN4hp2MUyokoc1FMaH6uXyXU5t7fi1T6krcThJN2H0apISNlncQYvCb9ysfKCQjIykyYCzTOCDNnBRZ5DlJRvs7ZaPgofXKv2OYuu2JzUeGZvDM1nTfeP2K7M6r2w9U0OITbiufKz+Z+j8Sdsx2cDv4YdsO1oZwDrN5ng4dzmfktkPevIpSW1lbxb9+/gwtfbvClKLumZmbGbHm3s6/BgwXFRsgOHLrgiN4ECBAmPy5zib2ESTM4keM4CijuepDhw4et0HvRdy4zXkEBEdRkkQJQyIFUW31PWe55z+wqRAO5dp8+fW0TZtyP7v4BCbP/Ac9ZSQiMco1lfZZnSpvxBkYp0+e3iw4UOpQYmv6NB4FPA5eFi1X5+T3hOyGxsbENDEwqpCJZofrdcEiBqA2k2GcwUGk2CHjWmVHJIfoNC+3bvsDZYMcGyBVqt5z526ofk5DA8NTBrXBLQuJ1eG2JEVUBJhwArCnT5ArAXBK7DWhqBGR0BoBXWmEkMjJCJqBIiRa0N4ESKr7AL4KL4MENAMEN4GsCxV3wZ4U+4Dnh2wdwHjhj5weYGYG7DwA4gTBxA4AcIN6HDDVDYh3QcQOsHEDNDfh6IbsOsHWDrB8UPJ2XvA8QOWHED7YdYPMDihwPbRT0gSB7TEAYk22gYNEV+GSFP/+LuSKcKEhgbFCjA", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "8255b123d7583268f839686341fbd344", + "uncompressed_size": 78584 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "3aa2fd61cc42da86769068cbab0f9062", + "uncompressed_size": 78584 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "5c717f1c5596474a9bfd80a26342ab77", + "uncompressed_size": 78584 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=16 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "4b69ab8a8634f8f194d84a88b044747f", + "uncompressed_size": 49080 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=16 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "02b8daab5dffd63fed3f6f2a1476e92e", + "uncompressed_size": 135968 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=16 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1dc20be8fec6bb6c6a00672beb6de51a", + "uncompressed_size": 119520 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f8c83713fa9e4410f0ad04e3bf7109e9", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "8ddc18f3876fe7d788ab11ae72383abb", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "fd5f56fb4c2e301659696d054ca7f1f8", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "593f6ef60996fbd698acbb9d1b754dfb", + "uncompressed_size": 49072 + }, + { + "blob": "QlpoOTFBWSZTWS2JXLwAMmZ/////////////////////////////////////////////4Elud8+lwraU9BnDd95EOPu98huXqW91unC93r2PXp6XcPIwdCQPcPdHt3G7wLjH33x3jZ7x48++d4D2+9eyu2vt32912d991zVbPt5eT777nubMUY+z6vXltvvb3vdYuWnSnNd0ux1eYnptlm9uu7OvbjqqQA8ESpPuw7t9enorJ1tYd9mVKVdzhXQbzO+7t73Ve2rvvSkAe7rezLro4PpwHbrrBezzXq7GkBRzvV3fdvAGKj3Oe8RCmgAmCaMTIaDI0BiaDQAGingyMhPQCb1NE0waEYmm0E2o0mmMSemgEYKehowEaaJ5MCaBqmwTJjUT1PFNPNGinqeoPTUZBqaIE0NATBMmmAAAAQGJoaBlGQ0mNTJmhPSMSbQ0J6aARPJTeqep/ojajVPCmxQf6pobJTepDxPUjyZQPRHqaaANDyg9I09Q0yDQDU0QAAmTE0AAmgTJgE0yE9Gk0wU9TxkAp5qptqjeqftE0U/EaU9pJ5T0nlNqemNKeo8kPFHpG0mnqA2o8ptRk9T1NDQeptGoPaU0eUPKZPSABoBqYRogmhNARgEMmTTI0NAjJjQ0ABPU0mxBonk1T2k9BM1HqmJ6n5TRqYnpNPKaMaajyNqh4kaaGj0nqfqjJmpiBoD1DI0DQAGmg0AzSRTSnqMmEmmgaZqTQ0GEPRMgGmIw0TTTEPQnoaQYRoAAwgBmptJtTRkNPUaAbUyDEANDQepoNNGgAAAADQAEiiBAAgBoCaGmTRiNGjITEwNEwRoCn6AZGjUYmJT8JhHoCmajBT9U/RT2pqG9KbKAaZtRHqep6nqPEnqGjIfqnqepvUmjQ0PUAAMgV7Bg0d+UmGeA3/i+8qSsfcnUu44eq7m+R0Mjsc2SvKzNmPVke7HbnXYkXGyMmMQxLtE8sPT++/L9N/yimmIQT5HogL6SzsdBuiUGpyxERiEyidyuAYb3O0/JTMV76aqnT68hJKBTr5HBdztqQnQrBktOclCqVpbBBYIPQmWSnnz9ATrDuyGzdgvzaMRr7m+YOdkkREQFD3avdRU3af3Jx3F/dxYEMUhdxZ+jVhNJ8nq/vkg2GvAQvvPhydxwcyz1ZRJWXXl2s0vxZgOdxPR+hIpmAi84WTW2UqADAiTRFzo1827E6mLSVDXdT52ye9CbeIbWjEl/E8x9bJTV5JrptdtrldWxBeWIKR5n1Lt27dmRg/Uwfar+Hf1KAQT91ASVvaQAg0kGMxIpNBrfmwAVK1aihSywEpZZbUgi2whSIIpZMPWmO7Vr45+RNtY1dXOMwx2LLHabvxzjVhJ2EnfEHOnICvXMMREiIFah77mARDhA4MpORxOtwV1WPR50Ei83StrSPt92lYVRrxjHzHREzNBHh5PRSnXWocCKCQQyUKi3bResyARr+bB8z27KSAiEFMzMzkRlbmZFbPFNkbMAoa15+LIHTNJDIoGZ5iI9fJVUNUMiJDMGXU2FtwrRVmVqKmEgFpLzUVCSBU3fFXE8RfFt0zclWUkMzqqgA+EDKCIhJcqE7QlfQaJ/KHRJwKSfRef4l6QhUkSSQ+XDIlufYyAqeQG1fkupY9yli8SVbBlRXtyoQIL6sE2gSWYNA0CYMGwTTiAaaWgWqJA2VJcMjmTWy7V22lAd5RRQ621wYOltqef22x07J0JoNJKrjxu4Mu5v8YNzIj8Tvm4oRASUJ1fPDcaGQFgZehXpWacaVcWnNWJvIllJtJRwQ9aODD2vMtQKGHPgiANsG20DYmDQ2NFNgjKqQESMCkCGGO0BFNApbUEBG3mlrIJcDneTo0rF9XpZN9HoapevjY1gys2LV5jVVnstnjs2bOSyIprk09kvldplPdrl2tw/zM3OtnGe522hA2nU9bq+J6/YpYyOyXab6KWx3PAifiVAuLEDetbuQRDjvut9XiAL8pre86FAVuI4h2deCu72aM4p1CvVFz4zyoJiIftxhyGpHNwIAW2CpDQHD8KCpIohtGV2Ja0u/iTPocioRs5NKlIBjODJnDfQKbQfWaW+lvF2kJgF0fuzqm5eBAmub+JKwm58Is37xWqe+gp76B0MKFVorM5s8CNUgGMAtE1nCg9ZjcfQlh5ZxesmXucxC43LayOk+dkyrNxYhah6IxDW1ErdVF3MeK26bKJbytHkpHRzxGVObOk2xqX3JS4Zcjk6D8GJ88mwr/4KrpTYvDtHH8JucrF8JYfEPavHmID8iCP838XS+H8c+t0Q/oHROXnm3xrd5EANEXhwX0LD/L94met24rET1hWW2CMQ4GS+KmT65qvCJHlq9WYQtGXgl6J+EjyHw/uD7rm94egvM5vN5vNVVWW8UlmM5oxDM0qdYY0REhi4IyUjJxFceaATRmTiASxIjHAZP3f72Px+l3PG6HSwf2unsBe1Wtamt9nP/Y534uTSwrFRqcROohYVUqb0mhGsm09P3DaccV7yptNfu/k+Cx4fI5mkzow4fF7P404C/P/6ZH8aX/skGI0a1Grv39ORJjRo1uJWrzJkyZMmXOnpnK8QvgGQfASRCkQUSqUUuOFKFGQUffZQq5DBaRCiq1zjcuKjIhwfAccpworC74yuhyXsszt+qp2GCWHBxqg12dpZ97Q09NpG0r9F7eiRaMmVPmVJMaZOn0KGlSp1L93OsaWpGixZGlpURivyI8ebnjO1da+zF9SwWpgxaibnFoZUHNiRaEmVLsUaVOfRpU6dWtXr2dLFixaF23cu1qNK7dzs/F2RAv374GqQoff+sXT6hF1SORyORfyiBECEB7w5wggQbHsRAwWx2PQcjVVV7ggBdByHNZ/n0uUSpZubDO+KjYdr1mlvVVJLSdTy1pJJy07GjMAMjvla9KfJDPTNyDShpUt1Xuu0namgG7KIHPFyeOSahYbgkbKJI8TXcZqlu9q5vV28N43PrHgpjZHcpYGMyDkI06kkHB7Ulk8Y9H4/H79C2jruFSHSrwUjOzdS9gJJWDynFJglXe5j8YiKhYUCsqlDj7jKoVpTr9aebx7dWlPR82rZ9hjqH5m4Pcx86T3Ovti8vTJOnbycTBR0jOkkHJD6MYovlTigTGEt08dht0XwvXjU/JhnvjreT91S2punW8SIDh2APEr9xZ7HuB2Hh9lyPe97H0dXa7mT1NzT2/eHt+96XvX5VqyYrKKtSnSo0NDQtfPpUaE+d35sx2IbvM7+AtWcCBrPtZBzsfgZPAyuBlcB/rPNZ3Z5utYam2T8jb6tvrzNoCEc0S3GG0tLkzZ9tydqoeOUAh6lmRnnFhFIxjGMGe3lszM0I7ZtlCHjszM0YxaEIQhCD+7EIQh7uQFULtCsLJ4/sOErU3lo+4HZFOSjOCRAfGHcVmRQpm/RmDBuETqagHvkPal7VPat7WX15WqgvHF45vK68r7x06euwevXr169etnr17bvbh7c4t5r7y6vC7wvnEpWEzNBQhyhhUgH7zYc8fXOgFCFw2n5tXmYFpPcVfP29B1qGjxQcBSBcHSXBVNTK6ZdcH7I873yhNEHdlGyMhhYRUecXuY1y5hsFHJxPXU4SmOiIiHr3LhfXuMaU155bzi6qWw21F0m1nF4zQD8sMJjypYkSxr9iaFpr1ktWE1PSnjOoCeJ90YEb+ZS5XapuXTrkbtuHa6S2BT+e85FNicrNGaLoujNz1OyGCbGNgmwSwRgOA/KPx5n33358EGLOubGKKKGIJHRDO3kXSggYjYOujExNdh4WGUc5KhDMBsqsEpVyHp+ZqrtWWCDeIdPxalTmodLmZuSnebQ5PJZKBnwNNSABmTnO1lzsB5oDUbcGX9lQDVrGbtM+iTb1FiKTCChS6vRMftApJU6zTae16BG0WtqAcS6GvVrqW6oGWZuTc0VQ8W+AdMDK/XcreeyAU1yDVeFgvAZeFGEHNVKQwadOJpBSVqMHBtNtt169uJ2QTKE0IKaaaIc1tvcu97wl5nBhP09fp8rghYqtYV/4cVjcHQ4XU6vIn8XKEYMwIdLD4vi37/EvgwRuLip79zZ2d3a2tpD59vb/FV4ufxKy6nQwU09jw5+hxJdxtMLCwsBsBuJ48EeiitpMUI0shHD0JdrK1abdzwCMQFbV4nA0mZqbaQFgA5XMM7A0WkRJbpERK4FjfO7ABmYMTtkBmApHJfGYYj4l5ulygyqXdOcNQJQgGoEA56sORjhhmjkJxGKiqKpVVLoBci2dxfYR5lGPNjUxicZwDBcni9nqKwEs+fjttt1w8ACT2x9rtX4AGGGDbDNHJJvaJGQSfBZ0kcGHNi033AvC2Q5iDqXSbwIrC5hoMK/A7ZqaLTYJ4w0jiOI4c2JNrfobvLr4G5zbgIHDhicplpE444oG220N6++WcdBB0zbpBxRx1pZclwsuUIGWA221YaqKATJGlIxpSSzCIiIsyFiGFmZrbSOMPv1OffXMPOLjZxXq62RSs2YBnMbOE1Rgt1IQbugRW67LRXO1oS78MDAwKYF/ibO/5i3jphOB5wQCAGSBw5suJVZeTKAcGQGvCtKClabTpd7TqUw21QbVXl1siaZq8ODyYhXALFhNkIQIQgQutCBlZ+N1pPCcnxL2aRJKTmc4BGUgcUhlksGhWV8knwRkz6Slo6u84pMOuJX59w7Njyu7FyhOi4uLi04Lly5c1uZifkpmrtbVrYtLi4YzNnPT024snTp1RWVdXOnjyrtra28iSEE75Yt19MgD3SK95yyhlAdgrhD9tXO072j51tmt2vwYmjLV/U9R1pJdvz3HSzdekq++rb3d4zPenrF8LxLI2at9D/gz632f9vV+k/AAtyAInACggRAjnNAIOE2akP39/pB4J5G60GD8LHAkDfq7/Xdcyyz8du66jE31eSLCGxs/U21u7UwTADBdmaln+LoU0gV05KrYn9nW3N9NdrRiLHj0bWyuDFvbjRGDKTvFxEZgcAxHdkEol+qXj3S2LqNAoOedpvWkgSEYkiuJEByAVx+5MQfAif8vwz0mm90QK7YRKHh978wgj9QOJGssnVNa546CffZQu7ii9ooBzlBJN4Q52j73whKcWZkaJqCr2QvIsduOg0yRMBkmSubXtA5gN4dXtBiuOE2dsOEJjMZVzohF9Xq+CJqBlnO1m+B5eD9EuR2MpyKaOkJQhjDciGg8AwlwMgFYlbINoOA1Jo5g7COm0+6l9syYI8Z9hLXO0nc4L5PCkhgWSY4chJCIyU5jpPZooRG/pFae+BQQn9IukK3YwDRKJE3SHCNbsceISJB+RnGqzFBxL/MjnqHk+2J4eryXEAcXA0qY15psa+vsXHu8idPaypUp7MnzJ8mfFnw4eZDJEOSR0iPucZCRb/jwECmsJvdP+41l551n63ZHgfowgvE+LsanvudN7i4fTDx49WHk8nUJKHk5nu/wdc9m89NESrufp4HS+c3HjG9weXPyuU/OXYPfjZxhq+Wdis9MY9lp77IbtslpaXIfZ7m89vqJS9Gh6qqU+erSSoIzCQkiqaUmSI6h/SQ9CU0Gzz8Oynta+BHc0fa6S6fuau60X1FOtx/F46ifiaB+sQE3HFAuAfgoB/iEBYK363zwYWGTgyRm9+8cz8LNer+H5/H4eX3On+UBJ2e93j1ldVVHdDv7RZQvSy7vCsuFq/PDb/sanZqfD/QnfWre4w7vb8TFiqZyEhFYecs/CSYbGIx8iLOXjuOS2Nr8dqSNIzBmkGoINotZsxoiDRAyZDTkGnBlCjGyCgu+f6np+9wOr1fc7/T8HH2uj5vprIyLruNLP9H5+NZ2gpaqq8qYlmuDsb27m59lJzLWUmGrRnCbPDwb++uLi4uLjHYsaTb9ZhA43G4nFop+cmqLd4a2/1dvt8/RHzChh29HUk20q7OTZy7OEG4rqvetuvq3EkFSr1+mYtEq+5c0TNxNeda+Z1IrUGIV6wOwaqb+S40uFKl9T/V4Pt92+u1PU+Xwf12WLiG4Tl4qCRQzs7OpUtJCBVDEIQUwwBX8mXlZXEieYGn6nK5Nn9X8Pr34JGdPTzV/V1jlwumbCvgWLPY7Cx5Z+9or/Y4tlISSSCRuai1Twn1RvV+2NK6wWEkLicAN+LfAZ53J7vclDXo+r7/X631XKcO3Rfr1KNSV3uOrhFYlasFYlAGfnUUe3IJJJJI/V/7+xF+x50iP7lfQkhG5lNLKJTRhNTcqbmYTXhdui6LrXoq+l6N+7YFixYsX/ubypvLlTC9e579gWBYEopUqVJv8649+1M2Gw2Gxbt2rMsrXQqfV9Qum6HQ6HR7FTFr/X93Eq/a/ns3KOSHxiwCA0AvR9ezN69e6yx7bLMssssssr79J+LBSWzSu5RVKeFemsuVq9GjRo/Wi/IyKnXq3JZP7fawbmVRrRPetTrNN1l0Vj1a2BXr169d+9YsFnDEtYGRczs65nVbtwa6W6p05sWPFp/24HWoTpzL2fins0p85DAPOnTp06dOfzsqbNE2bNmzJkyZMl3HbVGh/D/fOyYS/k9W69WrVmqdWs2injXz1UValSpUgqTYHs/Lf/ds69ehQoUJKFBlFuaaaaYTTTTTTpppsZ8h72xllkjjjjz8jM/zpi7/r/vV29Gjt/6ZPf9+X4O5ZUtWg3a2DodDtu2lbt9g5Rxfs+YlBBAIIGw+H+iMLeetlzpZWpWmmj/8sMMPcHg4WhNh5mjkX2xzcxO+vrFjP2Ue/yz7/dTTTXOLdqK06dNyzDhw4cCHD1M3BmxE1YkStFizZT/R15EF/LgSZNaTJksvySJCJEhiRIkSMyRmx5EiPITVkSJEiQ2kUhGjPpUehC/xlIpcHOZQ5j125c82g6ZMnCVjfV06dAqeWn7h4Mn2eEdT0avCw+NOqnnrNyo0UkkcTfNJpa/AnNcm1yczhvqW+TVYnMbcnG4Nu6xnyMJQcb+ixuCzlreztSLY03FxWUQrvvIecccccqa5iba6VrgUp2XwnlXsvXwPy4m6YxI58Fk+MsezykMMbhlmzNUqJSfCZ317L4jrrTTjbYlwoYt/afeeeXzJrVaSll272WKPY7qRyOOOSOVXKqSyyxxz4oYZ2e1x6U/HpUqVJqjrqb1CapQY1JpmZpppmw9M2nbftWrWutq2Dzwsvjz5I+LPyqijLPFnrT0bXIsYElOXIwJHJLFOe440000yyL9ROmmmF11128GHf5GRb6JkRE12ve979nosfHqx+Co7TtHv7h4e9oQoFthdWQVc3WTqUUUfKKKKNlFFaAKkAC5NGgUul6AclI65RoCFw/f8HQyOl0uVzcn1+mTKx8rZ6p7a6MDav9zt/Z+D+Gnd7bQ4O6VSHPwEXZVHD2ATk+ZBQR475po57fH8S+E+JP9/nMPdjIyUi4vy+gVoDEAB5P08rkURAHGdIxbHBCIIyQQg83r83ldbuQzD0ufrVaIHKIQhFjAQAQYaQw3IG67+IFCAA9P3+2Yluv3+9TxkJ53+XtVff7vOl+cpSAg+/+Hg/o0UY1FALDx7rUFKJAciUKrR+H8n9yvw/v+/a9+3b+HebqJ0UCMboEYeKRogQMmRgOqWDLQCAA+++/xpqGji4tSaabg/ejGxYsWPr4frYF4CwWjMM77va/elQf1p4CWo8VoIsD+309OOzabSVdiXAYlO0GRkfhtvwLn4PAvPwU0iowKzBcesXhFC8He3LNerxrmnnU/CheeFedOYFcaQSX/E8Kj8Gwp/gpAYTBmZGM+IB/EAJBkA0+fP/san7a0etWX8Ld3etK/Z8bW7PP+/5GfQoUG4GkQFMga7bs108ivRC6WExKQwOVecvncF5ZkgGza25QPYI10jPjNjAQglVcNcfF8n8fm+b9fHbOrN4u+3+35ft4fI/lTbKQlphfIfNhRAG4kgCBeMNu0autvuYLo+b8mbnZmbm3Ll7e5u67LUuF80iM2+4PMxZlhsC/aVJ4ZzTXV2RI3ct3Fw9eY89pAZUYJcp8riU+DU8yr2n+Hj8fj7GsIwWkFUbaDE5ez+D4fL+JSomYjGaWz5NXpcrl53h+Jh4WLi97XHybF0RIA5Xc8lGX953mySEpDO7Q5h1+97fNgTWgBwblcraauimFeZzG/ldRRrbWYghL8qgT1PM63R8tQVN+t6LTCo0R497HZ7H+YywWxdQlwEk+Vv+ToPgCkZqCATdvTI0NNpenNLlYNje8igQJgXDQ2d7M6f4zpnMCfuDd7RaE3tEUFyPA1HPUQLPkabwzTB3y99nQTExJTvfseinjUwgpDtyvO1g/XPzMzM6mqoizrcz5qpxb5+DgPzFGhempcztxaVfB4FZVpGO7po7qdzgIHuxDol7FH/VtI7vJHYc1UlV2Fk8mmEOZ22JucfyINWq7lbFJ7XneRXUdnSDt6TcO8L6xBlMU00SG21zRAuOXhT9lewRiE2wfYfCGxI09jnq9aEA5WfWQcCv3VGDTCqqlN528UzIZaEiCDn0+QeHeuIMoRpK33gEAW+QcxjcfDrfKSC0c5tyueAVaC3iKRoXgngm8MWzZ5PY29Oxe3dzg8HU61swWdVotWLG02soa2DBB2WT2NmQAkkkxMXFmSo4kANgDK7y2SsqMDIyMiKDxGHIv9W1CEKdeZY7SMB5FEkKPOjShap0LLxsh4UHl5cwiZEQd9EwLODZoUYRDvibH179re4du2+2re1nv+yYZUHpkbRePfa1rnONicxYBOmIe4IBS8f23op6d1HaRfEvCJSDyfi4yBy2aoWrUABBSA0lwrtXq8vMW3wvZaed9WTaqUaFsyALqDw6xgKXp/Y9f4H2qfvXrj5sADtvc83/eVVVVVpEsrgJpR6e3gdN5su0jFO9c1wFg1pWNX5gZjPYHKES6sE+TRUyljsTa20LCjgNSrbAxadxLiPHihPzBIoselF1lMoj0ktp0kGayzSn46tSaI1o6pbDcjeDpJT0oN8FGpApukciuNJO3Bx+jqLwLXVlYN/OwJ7GNDqIZ1YIJU9e6y14KcMFvkV1l0qXbElJUGE7gtN4WwwqkjnQ4TXE6Xj3064VvQZ7WHVp4scdiJqN12N13uXZs/XnyiyucaEhGR914q6J6ob0TC0j0MG8JLboNdDuxsIB7d69CKdj6k/YOqxPPZkud0cmkTocrIPPhuBY0sUc/G3+5ueDMfm+cfRPtSfFNrUq/4HDQ+Hxfh9OaY0r0LXhwUIQTgoIMNiMRMG0HgsFFxaSPQpUr64F1o6dPS1PgtcP3/Nh1r3uKqvfu7H1WXtk/umUEnkGUX7h2NA/PIz9z3x8kDuuV2apgYUQRnnvAdcR71Q6qpPIO6L+jCHdZpEkP5CIxF3S5PtOFRBxCpkd88hVy/U6n2EWcoe336Wqx0pBEPD1j7iHboNJcLbBxaQ3aQ3G6ch5J2ZbrVbDG1eBMxAyZEnSzTO22Tgd1uoK+djPSCiss2SoGh2nbrXbxxakREIZWkhjflFGE5nNNHYazRGpJjNfamsfu9vPRA/G3jP9DH2YJAB3Zkq4fu+6493+eO5wnbjZ7yIBKjAJseb54TkQMZRiQI2H4f/Gv8+oKtuXU3be1a4MTC+97gq2i9gNGGKD6FCshGkgmTjEAGlVQ9trUQgg0PbSGhCcCqNcH9v2754f9/7+9hyS/EudozxL42LQm02p5FA0sEj/uWNmH7fP14/Bffw86Tv8y/93yu07pfwc69ylcz8//TGMYX//T2P/V08jdwxTdW4Gc0hX6aQH/VpdxvS8MAxudl+eqV5MsdeAuArhnH4y+HwDaBv8kuYV6GfXr1avBqU2suRqkwkzBBxb/AvJtMUwFmlV5EIYJsMsmTdNEZszZlwuLrLvYNkGnHP9DB0fwGDBzFQ+ugwnle+d4XlauDz0udt9VJgDGLGIPEoCNtEH/A6n2YahmShQuKFJ9Tz+vFzacdywdeYg55iPxkpJVsocEn4HBj35fbjDKMR1OVmfX5A2ReIf+XD+0acteNtzh9bgb/+v+58+7h8m24ioiF01Vf9cLiXzrq983eql6eEQ9fAyUHBydwnlRvkyZ6/5v2rUQ03lGZaoy85JZFqq8k0GEsZR+NEzE87EviTfQ8LpdM6vqboPD7/s6/Vv7w7ljGIY6gBkGACGMRkIAQ8KpjbQONUMcdn62z8Nh/XsfL4uSiqM2ZKynxrVS79JtPOedC30bjboKMYCAQocB/muaBGhJMjXEufo3B8AAyPRILDGBiQPyw4AxCpChIWmGcp00sYO0cuZn9eQLk4H9DEAwFs8fmfzHmGgAgUAK+x+lkZNAE/kyWS2xZRUw8U7vqmdUPMDdoarUo8CY0s3s7zxTLzB3rGDvcn+76B0ImnOZni3/L7qToNh5/t0vjxruhuvS2Hja9tTDYJPa3sF+mK2vKyiw99uNbQ3xpYM2NCMLIlQhAhQEDzBYFIYIhRmA+/PDzrSmr93twx8V9eeDg7FasxVn5ZLmqpZts4oMihlOhP/nUdOXmrdrbz05b/pU5NVk5u5467htKnuZe64VZbyP/JjyA47dxQD3VAjoPWTHfjbKGwNy3FuTD4pAz6XP52HwPyk+j6m73w6u/K3p6JbhUDnb2Gcacqcgodkf1sT+rf/sfs3oifLlvI3nu+rGrRBY7U7MynYiSNVBsc7G4harZ0quNF5233MOt19313RXyW1msmWKwkCV9JVNbiikQtic4icjMERW7yYhrdYMLj7d4zdB/sNVL0F85Y9aXplHJOrkbWkkp5NLyjkmW9+x5wAb9jAKoK8K8w0zytHsOj9h9fVAKbGJbJ0ZgBSwRIRfCsP1OJXnWeWiCEgkRDoC50dL8chSTlmz3rDMi4qDtrABMs+usyXxG/ovmpg9fMI64MZ3hWwdpy8EgJTYx2FE/s61A+iWFm+K/rPkB6pAegjutrvEivQ/TtLbPc4AINGYxAruMKSnGo1oQ5aE2mVn31ceikggEAQQHT4kqL0I42ZBlDQ5Uptp7urJiXjWOhB9XI3Fzc4mqO4iDvMTSR9szu04fJvBxUInRgZBCCoNtmn/0X1TMzyDgcvJ4lteHm3olzK5BUmdJ/nfD2/7kgYmHfLbs+w0iUVTxYQd0QhAAO9I2bPTDZXP67bVso522ZGJZeZbOopUFTIK+7CxWKrOIgMxBwA+88Ln5e2KWHKVXpdagFlD1eHNjZVvbLSK00p1chDUkHzB/Z+tY2Wv9bXdqo2f7vaH6cM0goXmb6L1OEhxnqyOasnMpNStU6wGnakjGNHV8g6wYdpcTs9XSKqxYw+2kJFCS1lu/VXlJLyrlDK+1c789r/XnnD+EqhgZdNGaxd8StDRsvkI4fk3dpm4KFcZs3Pm016dtm4qLkmmNePRlxDGj6n8KaEgQ78BMfFf6m+c5cXC4Pd4t3sSqjlj9Wq/EcMm8QfO9b1vbs8+j+uxVsBLmL5u/Eez1E2Fh4BgNOK4yqgVElU0galYMfwlJqGz9mBWycGFrGj4ogiM+aBYTSFi8gAtBuwD/xdIdMDSAdfxvG6s7rqm7m67/pIH4xjxw4IS3TEAbtco1fgiVnc9rtGdxA1yCEgxCBKMQxiEJHBCiCYkT25ugu3z526zvk+D1fL8myK1uuMowePAa4l8r/O129egl1GVJ4LC8iMd/iwUWBVMWRRsZ98UObm3yawZujyGzPJ3y+wRqQU2R8h82iMIc4rOO5xpxUiwUSalUJ4Uy6W2SQOWr+HTpKniWMlPkSluSdGTn5svP9KSIAt6C5s68l9TAOh+uaFi8+1J/Bm2EZIxWYNbcIMBMYLm6XMRs1045saSpaDIJjR2ozuAjeuJzmG2iTDwnJYzIx48KkrnQJvPX13Vjj5TYZakAqS1IcLNZDJylZIyHdw1l6iuZmT8jkepkaxb76Lp+m6bk8SFiW0Zu2FrZWWt8RNOPOqDAEE0KlRKsc8csfh/g8EyyO150raltQauCIiIzUDcjhH2M2s+0aan0K/z+V39/b+x6nFuXHrtVgvIENg03C5uWhmlxFKpWY9zk3dSUMXUKhvQkPrs+yidLvTUjsEq6jPETpP6TJIhVgHNpFO+BTUIbMnH3lhIUP7RxoIDwD4vt9OmLvIbsquZoMAW3MUE4Qvkdp1GhsFTUZeKh5bzytnhLltMTnFhmDIiAH578WciIVxwncPKsNw7iHdS+l5/U9W/ik1gocGXIwbXoM8mEA7JTYUSOvAnbbLs+6oOVDfhud90Y2GW7ocdg3PAIDBEKEq+nffO0OlzdH8uQy9qYIELbi4ddaiBFtGQlSJpcPHcPU7XW3mUbbkOvt7ADY2JU9hDL8fH1bGlLeTl+ADIdiU77uGmzfL8vyniDb/HXc85cmsCfotr2CYYYTBHNlG441UJJA2UCBAhpImMtnb3NHGuuIbPYSNm9T2CLUA+QKjtx5FGXRo2kMbaCvn4Ow3F063n1469LhVCFOCOu+HJ32ZJJvYJV+FPmW9ng5hpuPeYmdJdv66oZfPTYV5cWNvkxDW4kN/GMYx+TiULRGJGgPmAIT0gmBgJfCp168F54QiISCIMQCA+AysdzO3U7kT29LLcF3XR5nTc57l0fSeQcKqipNTqI1SsXqNYTxICgC1XBXjSEmAoREQVKSzFqCt44eU+k2nO9fh5PYm1Em0gUGDaBpVqYszs/fbX3HZYuuzZ1Wy6+stXkmluWasCILsfg4tpsdpqeS6jVdXqdbWLe404ISoqpgQ06YJIA5jnOc4HL5a8SVOG0SfI1MVFwMLBzMNRreH7Idn8Dg/M/UuulOBaIODr3QHaL17qzonx2rO+8SWBxTBvk/aBeQj50XBfgwW3ky4bHxx8esxEIBocngd3mbN7rVJgHVmpmCtAkN9jwgA8jeb1vm7jAp0tWjT5zZxTIEDBQgLHtpaWf7/9BJWLay24lx+lJW3RuigLFOSlCpMD1/q+6q1KSQvIsuHaaa4iuHG85aLx9NowH4IWjtoAFF5AEuhBn/D+OPD5i7BttwkNx6CkeRZCqy1qwOqdWaisPIWLjKxYdD/n7I+vsyqcIkIkSJEiRIlJV9pGtT+tNCq2yGqowkCMizQCKXAEpIwg7+tHfuB3+FfsL/qYFTV6N5z3k/PxcjH5auNAFlTo5uFL6ZBMamhRvMUldErSll1ZDlSgSCBggeycwr/c+K1qdcuucuuNkcI4Y5SF4kBuww44fyb4AeZqeRGPR9aVlg0ogJBERhjIA2mQBE4GU+Ao04LS8AdPoQe/cJIZxdHfCjUP1TZ+5H7EyQO7IQnKsYjGPzXBjKg7FjYSR7MCWZaYOtN00myU8Rhf2SA5e3A+bbj0u87zed5l7C0ZTWU1fNIbSHUa53NOYczHkx5MeTJk3Wi0lLV77aVrupgdkDfIJ4+Bk0TEJbe2nKTNfibSKxBMg72xzVlAPFJSIKZkQqFWJ8HEhBuEYBiFTRi85rUtNtuNjVpiAInTHXRxpNPUggVvlB/4fvO/jFoRQAgs6ENoXYEt8TwWm1YZkalPpaxR8EJ1hYUFUoXsjKN8ZUQuOaevPHsQllWzGDHWuzyzsvoTMJIEcTjYozAOIZBOLBZxRltg1TH2fO4HA0ND3vepmdavKshWUFfRFiaWlfdSkZhilQhVpgaUhPmGHRpMAVi13L3HLxeZlZWPNWpouZQnZ9JDZnuGZpM4r5ejmUpTjvm5l796QW0YNpNhaTul7HU6W86M9GhPVpwbbxZiDMd3rS3kIKhqBuJ5jCN9kk8YwC/YYfMqVt0VK0jZRugW83lQOm3tKSqU6cJviuKakrfTw8mTVw6dAQa1WERQ5wRCzNLIRTiLJsZMmTInkxqJoyN2vRbt84DcGjoq2PH67IMjEBmdFjqdRiRpYJQmiO0DUEAQJKeSVE4pk9p7sv37/ke+dmMLZy1TYYDaxoUWfDx+kqsYPI1NJhhh27dsjMRKdn7qS+yreLLIxEYUCBx7k+Ce/8Dz2VmvFlSFGMiIM3tTB4pc27cJp71X1dXLme6s0Kri29kmZWVBCKzXRqVohTa/X7o121R2S9HaqXyvz5aStqDqRXFhErXCrIQgRPm9jpYmrssfKOITExuFGuLLdcgcxE2g3NvYO01eHkV6ckLJjw6rhs2lhnBwcJIhVRqC+Rf4OA3IkiRuEQvsafQ1S1dk1Xi6ey08jN+1P/UZ7bNf2rcbA1jsjc596dw4YqaDREQI0xEGiHCBZ1nI8d7OU70lcdMgyozbSrqWje1yFCRPodOQ7867rqZw1pUgq3YmvvcYB07TAakSiCKKvMzMzUBjj0qKlEhriG3JtcjaWObUNtxp7DT1MDUz1E0anN37bcqdOtwuirpbI1SIKfLU5nMtRdXMMyLh5rzm83n437peTYayq6eti2Lpzg5ydLglCF6sdBDFixIxYsX9ZeYuFSIIVVVVctLC9zZiNLocgzJBsPGmr/UveVvHnhcxFswTSG9u5XrJ7Zfl9aVlpSlhTmBeUOQf/SQukIEUiQQIiJ1n+rWp8X5fz91o/qeh+37JEPTxIFGGXFPdzEGRktncLRVX5WxA++SyB6K1fuflZpb0HpUb9LQFUaIUFIwsGCS8mS7I1b2t+1m/c/X7f0v5rbg7uNjcia3k40RhF0y7QkXbMyAgICBx/HSZVKpzNkka0V0pyqN2c0SDJj2I+HMWTyqWbvP3dhu7WKstBPoPMWDRDXAEZHSbOkslFkqKOhZrN8iiA22JiWaerZJwKtwg583uJZ+6F9btvK+h9Q9JZNaPuYsy7Hh4UaXyLtrBbaNsUNjQ3h6gI4SRQ3m9Srd3veXmaruh6bntPPLPbAOOqWx1daIlmKaxkJq/uvFw7+FF4Zl57USUawDcYz95cNkY5ge++T2fT7S8q69OvTBnMgDJEYAh8uGk+SEImpudMZuO0JuSe+dZ+dp6Xag50vv/W+d/Lm5Me5S2PP83qbXOsP3yfUa8jNzZ3kcuTlafc8dw1l2o2lTH0WGE8E6E0DsKALwKoWI1ZCOtQ+aM8D+fzIe+vdPv73f38uhq8rfTPgEBwdGnWkp1G5qskm7m1qPyNxzey55cCs3O3cWbl9XWkpfSewvrDIsb6yzMXFk8mbydF7o5T3aXWl55e7u9bgXk7NyVABArn623czjgtA5rh7iBDwLY2usoEmDkR7xI7LbjJTp12fPTNXAJo+sHZh2wY984Fb8jjC5XtWMLIwZE1aHgeeZQ2kNDsZ/1diOvJBnuuAkQ126CEdLN65tbCuZKGJSQw+5HhQdrDMluRAZHzjFd7Nx9bAoKNUqkrCTw+Eqh1UZhbMTHtS76HQq3z4GVq+fWto+fPn0RIYj58+fRLZ8+5oL8TwPA8CvMPC3cXaQFun8HDV2JBuJ4F3nwpnEe+1PQ5nP2OZJykBvLBklrLWMxikFVWR1tMBYA53sc+MF1cRfFHQbirQWR7pOOLThxsb9DP7N/lIKcf+aMjmhMRyYCKoZYVY/TQ8yc83gWYG/H35K0DPHW0dqJG5VnLVGodzPA+HhcARrnscAWxnWzu0RE5RdP5ERXn4PRcMuf2psAHmZ+WUcuf+9T5zWORG7WcpbZsqo6S5PAGctQRVxCGrOPd+Nl47M19lGYnfu+yntQhLXnOEtNS3u/CQ1kDWbVu4m6UTxw0jk7eYL/RskN+79if/VtHz1rhfg6UxJwxN/uJ+FYxEcVQcEqmXg+YPXA+pw40IBJnYU4wR+slxNygyaGAmXEFsuMbqDGL1/Pr+lmcnMhk1zqEhatMwlf90/jIh/l+06v+vn6HQ4OqIYZOjiFFZUkN3YPof8NfSfk0ZPI7A+aBA2+Avd/jiMbKAK+nMOidVlNDobsFwkCFddRpHRRgAzSGhBxhnM9LdHCspPreB1H2QLJG7toMI9fufpw0OWsP0db6vykhQIeFwvwkOgVkQ03EeLXiSWWCDRoEJ42hNybIyKQKBAUPTuY11G7iLX38alVKtFJiaEBmFJaWDx5Aft8jRz9C/BnS0y/cac1MzFDta3a7Vvgv8Fo/22yrdPTNCkV03JTQ5wNGdozscPYDOtKBU30x98cyAPPylQnbbiodWw2Gc2zmr0TDZ50CzuyuphUXcbvaPvX2xVFXMi3Rm4ILHncHR7zd8ezHjedvYQgZnxyrVgGLCJ1vX4coPMStDT7V5jUOMMpR5kyBMTIbD8ZrFPxDJqRcRdIzASo8Dp/4rpVF7U2XB71xsajHrrBbRGV2Tpv84Sm6/WL55fN/HHKP5p/I81fX9IR2MUZVNM5KMx940btoSScQSdllOnp9UjGSjW6Fy3JsTgVezw50WpRnzc/hLLLLLb0xZZZZZZZYFllllllllllllllltGpZbossu6t5VwSh6Kfos7le+DYHWXr8MPo9BRPZIA/S7Mqb97c2lRuumsPwVq1xYzxxldVqE8T+Bx1r2wOpskXho6u2u+UetsHg1Pt6n218PY+2vsk9yRlkjVyNBn/NR9nG/+CFciLDKbk8/FNoGGHBs4RKYSpUvRsXfS5yqEnOokWrQItkhY2M+u8C+7XpnZ+LIgGKaqeTuModVCscPRRmI+HOE5ttCfRoppLlz49gcg4RzkSCOceAkkg6SEJQb2y6ZhcmbYBrfzYpOVFOGb6E7ZixZnR8X0eNS2OVWsZ9b4HegW0d6gzZhhp0/Shq/BNUjSaO3uWW8ZJ4NM7DGDUwX85uzsUV4sSbMv35cix40r7aXhNTIej8XAcc3rcDzKYOOircuJCzHy1ClmxLwrm0FdAmRGP2URbp+4w/h8iytafKnlSonSNm5V/5gdaLb7fcLUzqaBIhNeXlYQffIu+YwYNHR0bvk2UYYHH8vTxunBgCCMUvtvRBeq6r2+m0VkLNU8oSNTAFmuTutpXYhPi4bdAZGGE4RXoeav1nG9YPj7+HQ4l7Vaz7OeQWzk5Owkx5ljLEz9L/L9uWMxOMvoXnNMEyptfcFi5+I/PS+Ct5aro9x/b+Ove9bbfa9f36odewI+G5W9ilCcQ5nTen320IUCH7E0aUZt57PKrCECIexpQps6eXeQqIrs5tv2aViz4fZdrBkzb6jVTBqYdbWOc6GZqJESrPC0iNU9xjw29dDQeic8Iub085GoEWuTE2xsq49TY+Pms9iTsY3bGyfZYD97N6WJWRzCqVNdPuHI5mfHVBFtgbX4GB+F6oOeWcudByDtH3CCjHdn1/RkklmKgbXnh1jqhQyitvg88OmAcAJK2B8gSWRcJKrmwNd8aG52ASAd/PRVv4qKY2abIVH+469ynU2UyyvZqPj0keMQ6EgRjeXbxxsssstionJeLpV75HUU13BYVK73m8gNAnBAB7ix2piyy48suDj6O5CRgjkGJvZ/QJsYIhEc4HywPGDekjHPx82cEg4+z7e3O84LngCJMDLNOJYDW6/X7DhS9fr9eyKZAeWxrNvlxoOnpqZ77LIzJ9KCbMG545nB1blu53KvKv1Zzq7d4IZoXA/fx8dpMF+4ln4UVFQ0NDpN28tU1ukXlUc9pBpa/X6XC0nAtdNbGvMBSFRkWIgjV0t7ud1Ggk1Vu48/Rqrk0/0fG41HSGTcdD1pIijbhzg7MGAwUJIgjkgX4cgIgItBSU3NBJ8mt98K0h8wDvRGuLgQYz15hn4JAIyAxjJE1yWDUV9fGOMY7puDKoHCSkN7nySKrBAYx4TfKty4AcpSxPb9Jh6uvGRwqzns+hPASYLNkAcKObZOqA7MQBg88MDvdTpJc5xM6ASNP7BwPaIzvotgZRFFwkz1So0TiD5QzTYHH3u5+9plylTrxIyQ8A9/1ZiRyswoXBYRkwJco3WSBVCkEAQIAgDUA7PmcYBhmztmBGAJcLYsrGiItJrOv8rH8PqWbLVBs5omLVmfG6FLnR813zo2fIheI+/Z6qflub/uxzAX78eclCnIEgkAie/OgZ9koDYArACG2YSQaYNF84wnMA+AeXPPWKQyBxmo8tPhY1mopMPGfZAYlo/WAkavrOYuVt6UHSXfjSnAd823rGzE+PrIBF0f1k77tqFCJUOAdF5O85QElpX57aq0G2qT4AENaAGkaJQq9Xl3aeFwrfK7z2fXBA1ZOY67IRmwA5Niau+5G4vruxl4xB1VXV+Dv0qOrq4cK72qtqpgJkze+WPWjOsbrG5S4X73u1AO2PUFTZ6cMZWOqAd5jO1SBxKZHFYtucyQ99A+mWQtzrsc1kMhU27RwkrW6pxrAwiv/FDTgMoOwVgHVFLnWpWT2KFCtqI+MzMypwG4oyLXKbFVYO3VfRXQXj9+/t76+o3T9+/fv3+g/BnOv+F9P6czTtTrZtAjHI+efoYwOTxur2DbrJdkbTzqRkv+/DsALENIuma4z1Uz0f5gBKLjZTjvQHj1LTpc6rjRabuQHOPnAL4gDK6RNfI4BzebPY6ufsDJnLQAB4cKMgmDhHKDKMxBAIzGmBeAJU0LZRLu9sLxkmdBmivQC7JiMeR8bWvnJanJpdXhtAwU4+66nU3T8ebma1KXtNWhcAuERpUwWSES2QOJ3upqKi1fM0TZdXVnJSa3O1gPu+1DQj5pRkHj3UY33CEPkaF9GT+MubpsK83HbxyMqRjqIjA3WdrbshsvG6+FSinmaLU2h9y6cnylRweMdu83Gu2YmhlCTPBqRNHYgRavuMzNCDqohqaJEnT9a1dv5kdMjKkwopsoOYpkdaFCcAQICIibiPn5oimyU6jQOz8DTbS5ZBmX2/UWXZ89b00gHRERuSHIFnkSrXp7+VeJ4Gb04alNq8zE+Lyknyt9eNs7eO5jqEc8wLuu+2EuVQupvBhczPp6eJqDGgGMULB8bGxoeBj8n5Cz+121W8jn17kGkYNIJ3lxBoRN3b5LzuNUUXQ5uXVpSq6NGIwmAgyQxZY5Ka+0m0LLRmXLIiNkgba/o0LGVxv4tyn4czzwOcsksjD6h/dlqqahgw2yNgBlgS3ciijANcYlymVbDq7wWDKdiuuuQCxDXYGNrna19Wo2FJyAD4unPftKzZntMgygchPSfsBUyTyqcxU1ElSTDssujBQnM2Zr0VU9NhKkz1jIrxG7tszI9J5QAp2/j4Uv+0BkOsQcGDSzgh8D44J/IrZld7NqhqiVoyvq9NGIBss/VzG7N6XEf02ys+ezCysoYaOHrdbl5M9nnxNHJZsaVZwYMrjoPEQUGdzgkwsRlc71pWhEgj3HjFQAxXcLaK6+QyVY9I6qq3syEkk9MDTn7o42ObNjZEsmRhqaq9f9UspT1QYxlSAJnCBjGSyGa9j0LXj8dQ+70A/vANM7jnPqGQNLJmr1Krx/GetYJJhj2ZNZUwTtHsoG8Rl0j2DlM9Fui3bZZ/cgcnRanmAGnAYQFAL+kq7J7lZQ0eTjQH5ZZYAYufN2mmdFpbgmUc+xJz5o4xNw1BNDh6MOoKMUD1rx8vEs0AIBpaas6uqiSu/6oCUsCeBilbnQ/3/v/wfwOmb4j5Rg8AMBygPV0FbX+KJI6Fe7UVu42AB19MzOg7OZ2vCAxAvQlpg/jfl6vi0+Hzfjx4ytVASO4BgkVAgG6AYDCAQCADA4YRD4gcoJgFecfs6QUgpAwOOEQpgwkCmHchIEgEoTAwIATBEIASBIDAgEwQCQIhEGEAgDAgEQCAEwTAUwFKEgYAa0objs7eDzHHycyXncabjVN5xji8WlLd8sK759xpZBGJvra3JJ4kpwky1kubsVklewAAEYMzDdSaGcUkNYab/Q0NB8naIyxG1cuSlXWqwTvANggBngciuByGHBGqtaDpLbtppviTpTBRy72xQ3hMqVK9V0wZqQIOYU+ET1QYyYovsYAcTEvxw4f5kKRlO79JpNibAbFUjebMIMzYKS9/ZCJla9eai2Ac4GCOeG4z4gjgBIEAMED2T5JKFy1ZPAbGh8w4MihHFCXQp16GloyvF+tcjtpU05houqMK2T5LbVZoMwzpAGMKsL/S73qYVrHngVDvPxgQsZI76M21ZI2x6YM76ebPYfPBy6LK+AVwuIBU4IzPBilJwVFHJLoE4gjA+8JAcqDMy6FChqalLOsS3Dr125kPDERQ8a9GhmFlqz12yGYDJfU1FsWeBXouGwBlQFYBMAIAwYDAUgMAiAwFEIhAEQBhEBgwYMGCIAwQeB2Fjm8ygijNSyLV1BaY1Gg3vOPGroxCwJIpwrothuvdcFYAGqQIEa5fJANkAtnIu3LcNTeWvLP7l/fwQb1+QEggkJC+9AyO+j6GJs5gotVJN+GWGWAtmBKBABgRDNCUJQowA7ULVEmJwOB6PFyJqHgH+RIUAv2MaHoeNr8/9P2vuZFWmN03BhWZBrfsC8LG/jDcwIUNTsw44XYTaWlPogyl+tBTP55CCVNNGa7HXyptPd0Z0iL5pso86fd7sm2Xnahqdjtf5e0M5tlNw5CEEH9O16VXSjpZa+oGYYRYAssC0G6qXGvgBDlMTQOo2/f9ThpBYIiGa6aXISwLQSWhgIaQJoECGk2IQ2mwbEmMSGkHDp87489MY2UQp8TK+Hv+97/jX2p3VNlzqCptrSgnk4kfsdisChkf89T4kn9XZRpUyApMgioyAOthc7svnYk6pvIY2FypY3e7N1q+DgbLgBVqmJfVq7SE8BBA4IxYuKO8pddZKWVc345OhnXuamMyi6AmOdwRSjajaXbZEjAMbJeOEZIVjvfHx/d2Hj+Nk9to4u+sy267SM9ig8p+DGGWADL0K0QA1QMADxe+gGhxeF0cc6IcnTuVgCaBDAcxSM6OR3539R7wKx1CAWPLtK8gg6tsrdu3GoZJ/FU4uL23eXag2kYOdDd+S7uFIH5Tsxpjrw1OSEM83cyiMCtRjgRbLKbhtvD40uOLEZoTepvqnRr5VOu4Xqgxs1/ow4l5NP5dzSt16vA9rcxpsp1oRcBtsI4+l9WzMGGmpwETtCbQyMYNaK4ojobtOHT1KUulSmNm8Q4ezrRP0oLU/zHzC9AkzbyZwgEhHLisTCd2MoWmJJkmbsNq6ZPM1O9lBRcSaGwye9y5kxPOcERFbPr81n0EnxARjmAWJCigauwi6LP5lqzauZ12tegvT6YQIAc9y5xfbPRT6zi6JnGbqQOQGKRg88kg3RIxjBfQVYqseOy7EmaTUdjmZmSlHdbrdX9oqVHZAsZ1ndSzM6vHz7PzttVJ3QOEIQbYjca0b9DVmUSmYJmfxMLbF5vMnnfk0fH5sretUKjAGnLT5BXFpeHYQXICAKiAWZ8cu44cGWsmWQUOHhpqWISsSbPaWPJLK5QGQ4Xd3t/jzVaAOXpSU9V+8h4XwSDRrV6paHQzxnSeeJAyJ2iQMewesIvNTZhrMVi1YpkKF0wBdzCAAwHhBAs48+HbYM78Xh0I6YRdf3986+xnclrBXl30FSQ7RfIeaTD0y8xa/40B0KFE4F+Tp1uT8LJx7a9do9EoZ5CsN6AQMGwYgg0dvWkC5v+2LxhVgB5gAaYWgS1Avw6gdqEaoMCmcKoB5lavtOtwvVNIO7O+0LzRwQ909M7tB7yaT+UP0w64iofLqBAVFKEEHnL90RUEMRGZFUHQIiqi8Uo8GlCFMhIVUq5D7IieVTB1vF7s4kGhuUl7Sf2kohsOdXGHHr6xwtOK3+fq4W37Xu/Eq6UeoD0gzL55MMx0am011SmqR8oX12EKYxTKIAQkjVWuhE7+fvbVw1p0k8/gZdSDmqkxCqEyW3HhKYR4Jh7OMN8iEG/Cs59KtirfExrJYHF3gSJMlPUOB9RdixdC9EQSwD5j/UZ+r+66EchagQLlmr6RNZrzhxwOVawMg22rVINdpnrZNYa1POfj4FOxpeJpabVzqwzykkOqcsJSuiGz/sgAQcevoa2Uq6bAHogxjgRSMDd9XFWGOLrt2fIW8rv7dTqLdHqXep6GdEuFKkcyTJ5fxuy6u7LXN1ocLHlJAziCVZbvYaEwjHEUgzxYO9NAMAEwGGIB8Dc8GDrTx73h5SeYqLKOU6zUYNypNwSsz9B3gGB6yxY2xzw0+PyOFj7jzaI4kKT3y4JcLcxWwYETC4ZzTM4UiUyVxKlVS2wbMSkSvRHYer5WrUEflhnqvfFdmZoqDTGFXr40FgWCq6Mq2Yy5XMGLuafgBgzvyeCvsOPQVUeEeOF6YCQF8BBwE3oRKLXEYPA8jZhUMQwPdJA7HD6pYrB4pxe1WHfeMFoXcm2SvQ0A+UDR5Ae4jNYblYcVTtqUJA8gL9LHL1CnTgYnRpxqSwMFW5osYx0m6XBrjB9XXX63gxDF4GrhrAHd19j04yyqpQ9uXQghR2CFkoWJ0nxDgNFgOPSQs3eZ3c4hscAquz5TONzcWWom9J828ickkc4ojJmDPfg1JNHZ1htRfMusjTTEb4TGiAK7eTOIkUgNb5KmTBGKytE0qZN62ip0Of4xT/P0+PPGybe2acnQ636jcGj1dcUf6KLU5MIapqc7Tt22YvCfY0w4o5/hYfdk0jHbW3Daz99QeiDJg7XyDzFj6y9OcFkyMSrS1qj2oa3Upfqdvn1aFHXcTL3eo5Sy0aSPjYm5X7MY6bYmTu9NZPF3siwa8XR1suGuY0kfsr2P5K8bWm76Pu4R3KK/e9x9PqCOiIwrWpXubiCax+StkvHl7UOYCS/S/QgRoa2t/Pk8P83l993/o4T6Po9Li93egVaTNP6oCQG7Xc8oR6nK3CTERPB18utDic070PAQbcM4RT5trqR0a4DBiGWAs1A8sRpaIiUnA4hQkv4gGynaYcKEMsuLTiXMKxuWxgJ65AiBGMTkYJ1U2NO8OWsGB46gIFEPeR0rzOOZR42JT09OjT0N96WV6Wt6fyeCuTni5DDdCOyW6at6MREgjWuXurBvaCybbjH1uzC9u0cFatWbNm+PHofathJsA0IWK/IbeIh3gAwLnMcayso3smSI70S0uKI5NLH8q5XJVf0b4A5xUDVo2nnVhG+Etv0dveFsrzpOfDxV7Dorauhq+rg9bjbgVLRVQyhE+TXtiMYJboRDru3Zy6+IIvr3cesFYVfLqXEHf8blSF9iPc6G40D17fXuw+U+vVV1hHAwtlwPIIXm4Ohm0qTAzwYF1RUBMODsgxoEoQkDGERSJJllxZtehGYRThMXJFUsbilo1gBEAz4DEeGQFCBbo6mocAQp8YIA6PH+necZsyjytfNGfU/I+fOnmPBQoYzCZKHymqnNFg98GCm9YMzMzM0GZmaD2ZmZntBkgqve0ZqJqaKa1S1TVo0VozypooprVUkdFaitWZUe99aitWqsVq1ixtw+Fj1dTwuB4ut8v5nAztASNtbW1EZ6+XIWhLiTbe0bTKYkaKplLIAoFKQDUveDvw3IbQNPlVvCEqoVivJtbWAAP55GLCfe3oBLW00hzJ3I1YGX7iWsM9c2mw2aGIxD6ZYddIoLihrDP4Syx7CJLhhPKG0IfhyDohosPUlaLCZFktQAxpIsnqRhTA/SUMafGD1nysHx+D8343Pfh9qAO1v6hyx5HQxTNIaSWj9O+iVhGD2knQDW2pmbwO1rdDbyZeltpap1JIKVoQhDGNoASEAmIaQNNANoaS7g8wYJuHA0VfFwTly7UYVHyEJ9EjAJ4YU+8QspcbAZhRKDrTF+qaIK1NcAHq6rk3yc1tjZY6a4xuA/GzK2fE7Ma1ZsVAfMw14iGwPoZ9ryTvHhuQDDjNYyAMJQjBRDknlm8DoJd6izv/pgxdoFatUqhZiaqodpgPmcUQms9/24On1fejsMGJZqcEjclCfgzsCVS0elXrswIoRsUtiiIWcsR2wY6FkmxKIZe0BkBEyLcgQQMLQ/jNTG7RCWsu3ZC26TTDT+o+ulNJ0PpLY32lWhfRdqqJDSldC7du18oHsdnNSVBinW5qZum3PtTW5u8eK1ENX5IDwET7sCs5Q6BjJmTqc55fvmbLksJP0AqbGqFkGImAzr4Li1NG88z0O84W/38zkToxlyaFBhDY9QACTevXnfzU9EWSSYSeW/leb9Bvp54mAxpAMKQeKhZ/zg1Jg6TMTsJr2SmJVrXBt363WL7nrw8fq/Qz/cm5fWxOt+L3cGOGbCsdfjogb1RXZm7Ov40t6j3dv8/cH4f2kd/5Dr5XXw01oGXGThREjJVWZIMmYhSS7+L3vcKOCNn9d1OrYnortfLeh0Al7JFkwyQwTSU5t6ZWDNwR83+lbI+ZBSM9nz2/YhcgHei1ZAFCE5qtXytZCaZjx5sNXNg3C65kGQykkaemMjvPOnZnQ3hDeYl9lNOURuCER42n9HNt7hnQv+fTqs/5WFe2pnV559FSruFTKKQJ/Emv411zLdKHyatXnL5lW+PRmzMp00occ6lf5t9r8rG+bu9DfOGbbzaVCt6liti4sDQ+ZXlDrsjGE7xrfxRmRCIYn8bEkMLL5mQyyyspps5gzNjav6E0YiMYx196PeyhrvRnmC4s972Hpenhbre8G4qX97S16411h9+IRM+cxIyyGGMOXR6PA7Pdncvb92l2P2XXYon2eEwvFEGGB4WUqqqooFKtNmnTYYYaYDDDDDDDrLLLTIZQyyyyywwrSQefoLRxqGWD8hvBP1bvIi6Ii6Nl9vB0DKEPSvDULlWcWzZ7Mb+1KW80e9oGHmTCaMYdlXLc7mIjuZStC43VHA6gcLicTrKQlweHFhvrLBthHKjxJB+qt0FrB95C4qgKqhVDXXNWQMim/lK/2UpSDMzQ27MHv4EIZMBGC4WSOFbh9jTBAmlzf1x9nZdhWu+1u9vkHAQhDbb6MYxEoxZmaoRG+43CjnswYHhRQUUUUMzMGbAGgzMwsRjTISwZsKeecTzzzCaUYxEBAQhCsGYNiQVUXKwePVF0hJu9lDZW2kEzw969sMLkwetkaWsJPXW17UBe0KhcTfmEJ7zcnEMAtlufqK6YnQ2EUEVv/r7B7lbUY2K9z+IYO/puVCi8egwFuEDdgiBESyqrcIdtBQ4dR8F0xwg9EpwSfEAeNuk7JmYyUdqiFM7LiQtWFDnjLpPxYnYCV7BsV3ZWFfRkKzBz60SPOgSaIS6x8vSLJf5madO7VCTpjjhtTRCGSECWmVkQsYjpHJ88QQ4goZRCZyEYTDATskWVk3yZznxIfUZYSDxPhZx4FnbPy6rsCXSOffgGF6VEvAQZJDqG2yVrfT4MUjFzfJPYNYmMZUFstW9lfY2kuBs3Qn0YxwmB8ueVdhl/phjhxqojjnsnzPoep/ngvU9TPxTMf4ASZb9oA837nocWlpY24/YTYyeZp7nxSKAclERzPhT+HIf3vqcqsaWRCFowfnAwiL80RABd8GVcHswnI1I6eY9GDkwYQ6U+TQMPzCW6ApoIQjYayfvLA8sDNzDEO65mzSs5RKbKJAMStx65jz1x4/yd5y69TXnvRuOErr6+DkYgfBvgkUbf8WHdDpHwjwuhpMU6Gy2ndfYvoyZzNvqAHtn00fS22xz9nIlwsaA3F1GUMQ2K+cGhtU2CPSYkl5jSx56U/t6/8anJ9ji/zKDc7HxfL29b5/Qq9h5VeoBnkvA3fBX2hgkFeAMwVi0vlN9lWqK04kCSi1s7GqEkGm2Y54Pin0QO/SggKH0BnaHYRAlBdYpipCeRI3352wawKjRJoZm2yC7YsAnfyz0WGCEl4YnoHiJyFowSixNu3blfR3DRRTEYLBguH545Th+4Y8OoTU467hlcTiki+kcfPIAO7ohShGmieuS3w8r5JDkpCWrSCCkW279/A/yROD/Z+n4X1970a7m8rleh+LjV5/o89bDVKQgBOAMZgkOAxCXjsloMOOZA1HDseI15bI6cYOXNJTUtQiqDrdNizPswW2UboY9q43FBsG/am3Vy+H5uhy9bjW93rbvZDuuZ08fHx8YY8zF3XmdUbMGwpPeEMj7A06L1MffjS8BSb3lFl+s/PoQFCDEAtgMQsYc6xdzvdDb+dKvzvS9Xzci5MeaOxCoTPIcbPUG0xoGwnYEGrK3KvH9JkWri5HZZu9n9PniEeJVqdOvL1iztPZ5kqC/9Omkl47FRLUpp58pyeNPdrz4nc04kxA2utAqb2ATHow/10fa/JXwaBdi8hpTtYFOA3fIkaXSaCBRhRLLC+foUe0njSKZl1gFMEmmzoQbG3AUGIGkkmIA3gtJUTbU0ejnXCXIe7nK4JbDRTO6yhfMWvx4mrjXPDBEA3o0koCDMa8xH98WndgDneGt7JcaCLAxLsN2wkaWk0rLRO0AYoJnvM+i1VfK1aYo3kIQ2BSDmVvtvXsD8zEvpM7UuzRsWLFixY/H+o4Kg0fvwnHOHnk6ymmQ9mSIR7f4ahJm495axROC8f20OrZ2Rnh4AISgKwOX8f5Pzvh7zjt27ObSaZScMA2dz01OdbYafpKAV30ps4+Y08uvXr169enErfufSaFHu/C6zA84z7imHMkDe7gN7MdsI/neDrJfclSmpjGcpliEXmxo0YRmWoFl1+zy4Zh+BkU5QuZ7DmNfs9ryrO8x5rzssvF4f00DfIAw+g64T+P1YYMo+V9zR0YqphEVdxRIkCRG9+l++yDJlXtIJ0wREPj8E9E9q08xoNOHkaGMbaBECDEt9i7Xa+NNnqzqL+h5dK00aMN3PMxed1+SvRZdt/eMLfhp61KkKWP91wfJkpt5GX78PGk+FYOLOsHhk4MAhQBtn5OfbR7FLIyKCRoMiET+hR9h11un6WDMO5nMtEmDE1VVpfI0tI0tDR2h+t/v2Btc/pbS87/A9bkUebmArhpea3BNoTYgQAhA+EIA0gTBgga+ov/JIKj9kznHKUJpBSBFMZIDjCLmG21JGSEUifu/i43W3u9vtHLuZVOvWrWJhqDk7NnZ/Y9FNSEdjqvqIo0aNEUeTwP6Dpvxt2XuY1lQ8Wyn6SPg3MAAXufj8/01UN53sTqVIVsbFxTEp7W6XY2qMWKqf8nRGZEIrLLOgtNPyUshXEpmGK1moUiEJI5TmfUSKtQKIKlCByqFJQIFCBUFRAUrOqrEUkatI9EK1EC0VVQqAkgMVFqiARJBFKQlEwkvAvIIuXIBAGlYVhqFyFeKjsWIKQAGPC8wq1IBDuKDbQNoOqyVo7b6Hk9nxcGzg937XpcuzffepPCnz6eMY3dPHMf7bee3hypPb7U1OBwJ/A4Ffv2sC29NUFGjRoURN3XU6Iv7mYV8WCEH7wvHLkG8cHDpTgjvZxBw5wZyJvpv55I5M5Q2eWpzRzJszjD0BrzhjzJ542x8M4Q4/XB5w6I9McwdKdecAdkckcCcEeQOhOwPCGzOJPGHHnpx6o6YdMPHHZDxh+QDIABAgQGVjG6uqoJupeWBVhRyO3Sx6KPN7U65c1rju1nw1dDuenqF26fDSwvmFONvW1vGjIXnyQZc6cr13GUhBNGi4UeEVFI/ijwBm4JxJ/06Vl5w+HA6lVVt/Q0tJdUYM99lzEpURiUsSc01H0/G77vx9IYHvedn/HxmnJ1s0pS+TYWM4xmDA5J12JjIMZuAYMSwyJqRtJXuWtDfL775119oXVEulYaUlKmn+Ia5/Ez/iAxZv3a1z3AJzLmUHdHnW+d93kaPIvfJxZdPrY1W1Qo2zXh9iRpjB5Kw8B40wPsM4DLqLyOx8H3bn4KuVX+2OsG3u6ytHDw6khCXYACunlGQtypYSUkTKP8+dO62heqb9cVtyv9fS/FAwO7RoV6EgxoRiDgobM5LHTzDmNrxg90AbVmDHz5rTn9tEsW48VXFHFG8iXqBbY5c9CC3w4HTIALBgGgHdCAGmCpfarly1kAZqogkIAdiYymb/Qmbkb1Bqn+/d+vSZYRY6Sko01gr2NfNUTulutmZscxuhnVooo6sYUd3DrzcHUu5x6ehzyGa7AAl8q8puXW3t6EGEKPVJSSen64YFnXX6O0tJSDP7rWzvhjI02tkmKXc18kEocldX9GhYfRo0mx9J1RpUfs/X7oDn8xbGxSr9yn5EsQF1/+fGx6+Xra30QGtNdZrvPj10x9Tf+A1fbqIkSBESNOmjDubomo9lH1cEay9Pl1ce4rUiSVTeQ0qZFx1+EJpFKa/E0mM6ojrqHm4yvP2uY2Zr8WHXOz5hKmOKx+PZaUxaiFt88ESAHB4JRWUU4s261hDLKQzSPStWrUHIVwTsm90vsiAb4DVQI36o+o0HuPe7A1EDj280QRezGBNnFvO1I4WmCR9EF3QciN/McTW81eY8SmIdnYQeZMmfoLPYMKcCkSXPeFZMTvdqL5VWExTbh6+8mJ+iqFf4v9X9EBkFZAeYbESITaPsrpJxd2Iz/de69Gj0cX50AGFHpSTmaSu73drwpwdOJtruQrt2dD7UVaAuU1dLCyFsLiYApMeqKOrfFKtwlc3b6gVGQKG9YQgs5D6ruy/ylz/1iwAbPr0hnwGsKENCvFdu8x+VnUxRRFkr8HVk3Lkw2CrbdffhYZT2E3g7FdCYTz1fW+DDbW+zb/y9Ol+aBX5Tj1B5R3VGGgICAgNqPggR0hcZMpW9mTYzGes9755+tRv71awt6OYo4jeBJhIg6CWjEi3ysCZXJzUTGoMqNg5ia3py3PYedW61NMKhsKYS/uatKTz+dhZHPCXh2sKTaJhrNc3vd7xoKsyEG3eHh94a4i8Q9ShQoc3bVyvF8upbgjDNkex41Ss1SidfoLTKlQ7xww77mw6qJp1KlTfbaSSWItdnXqxaL2rVq1YMqSs5oxUw2CXd/tbcvXtzIhlpEqVQ3pEjOlMkSpEcidSyc3wfB2/biJXHovuidRQ5wMc9jhJtMHgsZ/m+bQoTqFCE52nlvLrfiCRTLgZsQ/Y7CRRy/oeK5C66sG7WAokOyefVvr5RjN5XKQL/u9/8CD6Lp/o9nlZOrUWbp9PzHZ8v5H0fyPiXXWiX0zwefnrItGLqRVmpzNlzp73bbORs1LIhSNIbBXuNjY0ggUv7SBwBNIYjAVAUKEEgBMEkDAGga8FS+UnpkrIQHaOT+FCcbIig2lsMzz5YXhjcq3j5FK9G/E+DMp1BfhDA1n5SXroOCp40OG+ZmZiBuOB5H3QDHDYA1+6019teAQtvD8WrkXTaAMpuK3ILd8sFY3fOgiBm2ZppkeVN24BoDGNuob05rf0ezafy10DZ2SyxZqXAFRRCaaVr8pYoAABhd/0fq6icXDOlkW3Mtq9YZtAIAK1WtXn2fm5FAAABTvrO20OtZ3NE3b9EiELdu3bgkUnTpzQee0OqlA6667gtPNuUY4/luCCDMf9UAvpfvGvF9oGAL6x02/11Co27CStZXL2SuJKkbmKw0rdh/TEr1YTaxiSTxXvG4peSySakJIIALJAnJEpI1JCEcFBpKCg2oJwbIEaBwbSkjbkibhBuDUGnBqCUGoNKDg1CDckSg4JQcE4JQckg1BJwbg4QcIOEEoOCUkg4JwcEnBuSJwbgnBJQg4QcGoJODcG1BtQbUG4NQSUHCDahBwgnCEgAESaadA2kkNtiaSEkmgEkmkhghgIDGRy0xPX4sRotwXWhcuSS2HORIDQ4wIDiMi2mR6CSSLcdbbzbWrrTx1c6bpOSf9Kei1Uxv5QFYYBT36qOICFS/VCSxYnsbbkRk9fyqdmzatfP8ltAgN8vptIqV0XaYmIABDW3iSyCpoQmICNu3Yots+VSO/+cqo20IG6cAICabG0IAbbQhMEhMAQkMQDGJAkIQhAhAIY0mISAYxpCEgaADKijAAAQCRBKYLFqC+TfN61+C2SQu/fh57Jk1uZa9jDg8n0/x6fu3r6M3i9oBuMoZXHl5SyeMqVCIj2fSykBp57Nm4dOqDnCuGEjQEV280pOgnInKnY8ZZ99997LXXW7Z1x1R1U/lrSOuOO/K8rtf21+nCMF2NMpPN9CjHJJHIyp12tRplpR2ou7qMLrrLtnW01V1llFmWV1VqfpeAJJSKRiSpP97YRcZPB1/imXUm7CeU+Z3EvWqkhAYDCMYQIJn/bswFjheikhmNAQGCbQDadr2zd3Qe/4ROHqzCztloYUe/SSdf2dzTgtM3cxhYtMA24PhRUiTSpmcnps0VsEm0jlVJEMQkNDlfui4b/4u5IpwoSBbErl4A=", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "e6544c727698e8110dd4917cd5695bd6", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1c300a8b8f9ed0ac68a39019d9842038", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "eefc7299fceddbabedc52ae8ff757212", + "uncompressed_size": 32224 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "c0df9945ac6194b68be739a3b07cc65e", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "bc154ba393ded5edc995dac1b4b5a7c0", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "b15584b2f35edb33be8f345068b26269", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "30536261c248626e3c8593f8135f8f6e", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "676ed3b4a7b43eea908136605de89448", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "394bbd1eb532b2015c90cd5c93b84fce", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "810daa314a8028d3063282fd8cbcfaa1", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f64e913d722118df87869b486c81e1f8", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "84964f9b35beffbcc7c4982fe4e3c373", + "uncompressed_size": 32224 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1fc7625b60dbe46d21949dec1c23b6f7", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1efda2582a0d2ecce7eed201f5a7a85d", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "3cd01bfddf8a2febed11126c12a0031c", + "uncompressed_size": 24000 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f19b19c70c7df67e781a5f96753e4526", + "uncompressed_size": 44512 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "168b32be3ffcd94e9455a5f0666bde89", + "uncompressed_size": 44520 + } + ], + "perf_compiled": true, + "solver_id": "ConvHipImplicitGemmV4R1Fwd" + } + ], + "network_config": "128x28x28x3x3x128x28x28x32xNCHWxBF16x1x1x1x1x1x1x1xF" + } +] diff --git a/src/tests/fin_output_perf_eval.json b/src/tests/fin_output_perf_eval.json new file mode 100644 index 0000000000..fe8aff510f --- /dev/null +++ b/src/tests/fin_output_perf_eval.json @@ -0,0 +1,339 @@ +[ + { + "process_env": [ + "LS_COLORS=rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=00:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.xz=01;31:*.zst=01;31:*.tzst=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.alz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.cab=01;31:*.wim=01;31:*.swm=01;31:*.dwm=01;31:*.esd=01;31:*.jpg=01;35:*.jpeg=01;35:*.mjpg=01;35:*.mjpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.m4a=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.oga=00;36:*.opus=00;36:*.spx=00;36:*.xspf=00;36:", + "LD_LIBRARY_PATH=/opt/rocm/lib:", + "LESSCLOSE=/usr/bin/lesspipe %s %s", + "HOSTNAME=cerb-rtg", + "OLDPWD=/root/dFin/_hip", + "UBSAN_OPTIONS=print_stacktrace=1", + "TUNA_DB_NAME=tuna_scales", + "TUNA_ROCM_VERSION=osdb-8348", + "PWD=/root/dFin/src/tests", + "HOME=/root", + "TUNA_LOGLEVEL=INFO", + "TUNA_DB_USER_NAME=root", + "TERM=xterm", + "SHLVL=1", + "PYTHONPATH=/root/Tuna", + "TUNA_DB_USER_PASSWORD=root1234", + "MIOPEN_LOG_LEVEL=6", + "PATH=/opt/rocm/miopen/bin:/opt/rocm/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "TUNA_DB_HOSTNAME=localhost", + "LESSOPEN=| /usr/bin/lesspipe %s", + "_=/opt/rocm/bin/fin" + ] + }, + { + "arch": "gfx906", + "config_tuna_id": null, + "db_key": "128-28-28-3x3-128-28-28-32-1x1-1x1-1x1-0-NCHW-BF16-F", + "direction": 1, + "input": { + "arch": "gfx906", + "config": { + "activMode": -1, + "batchsize": 32, + "cmd": "convbfp16", + "conv_mode": "conv", + "conv_stride_d": 1, + "conv_stride_h": 1, + "conv_stride_w": 1, + "dilation_d": 1, + "dilation_h": 1, + "dilation_w": 1, + "fil_d": 1, + "fil_h": 3, + "fil_w": 3, + "fusion_mode": -1, + "group_count": 1, + "in_channels": 128, + "in_d": 1, + "in_h": 28, + "in_w": 28, + "out_channels": 128, + "pad_d": 0, + "pad_h": 1, + "pad_mode": "default", + "pad_w": 1, + "recur": 0, + "sources": [ + "issue_1760" + ], + "spatial_dim": 2, + "tags": [ + "resnet50" + ], + "trans_output_pad_d": 0 + }, + "config_tuna_id": null, + "direction": 1, + "is_winograd_only": false, + "label": "resnet_tuning", + "miopen_perf_compile_result": [ + { + "algorithm": "miopenConvolutionFwdAlgoImplicitGEMM", + "kernel_objects": [ + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=64 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=16 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=3136 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=16 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f8ffbb181ddb59614f385a4d73403e5c", + "uncompressed_size": 25240 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=64 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=16 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "cad4bf973c5625393b6eecd6b9893f88", + "uncompressed_size": 54040 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=64 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "048a2918c11084f40ebe8154a909fc8e", + "uncompressed_size": 54040 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "63693f0680b6c679f3798e138c73df8d", + "uncompressed_size": 32696 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "42edc5ca00b9b7b566c8110a6dcd877c", + "uncompressed_size": 32696 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1a23762a062753e306a43356eb45ac44", + "uncompressed_size": 78584 + }, + { + "blob": "QlpoOTFBWSZTWcDYoUYAWjJ/////////////////////////////////////////////4Hfe97z33unpVANBe86gt77zXvPuR9qxffHXxxctnLe72raFxu2MjMLne9zd4A77O7rj2MW+N6es8DiD3tQOkiXvX3uZme5110ZvvZ5duBj7fe92Pu7W9ec7nnvu93p8Z4ffM+lHR003W87l3b7M8LRy7e1wvPfe+p77Ld89ku7LZVzSO269ve3q29ave65pm9Y6s3R3uve6Fs6XlnT1GNZrNug6H2wOm1m299vVe7dzFHebsx7N2cwapze93r3ba3bm97vPb26bVGxqtsKoywA7uuxo00ptTWy3rtmp0G5TUTt0LeA53A0C1Urx8vgAAA+qQ67z76dziM56RU12D66Ozy6wA7ni1VXWSSh9sAC+eVOXsPrwACPTbYCd7Ud7QDU0hAATINAAAA0NAAGgAA0GjIDQABDNQ0BkyNNBMZINMAE0yTAGpiaDTSegjKfpGTU/TSelPCejTUank8phTQaIhGgAaAAAAAACYgTCYkYEwk8aBA0mmSnmT1NPSDEjMKbSPU2hqnoyYymmKaaeRhTE8U2p6RmmTQGhppppNPQmT1NNNNPUDRAAJDQE0ARo0MjTQmmaaTaAZJhqaTMEGU8lPBk0JiU/RppJ+VPKfqmmejKelB6Teoh6mj2lDajTT9UPKZNGgDajagekBk0ANmpqNDQBISIQQE0yZCYAJ6TJiaaTJpkwFPTRM00xoKPVNtTJp6RlPUzSMjajMJqemERpk8oeSZM0jQND0Q0GmmRoPU0GgA00GnqAaAabRA01ImmhJqflTxJ7RR+qeo/SNGieptTTMkeTRHqeU8hPJGmDUBpiDRk9J5TQ0eiH6poaPTU00YTzUanlNHkNRgamymankj1MaeqepkbTJMTaZTBNPRMnlMgNBIogQAIATACANGTBDQEwmBMJpoMmSbSNMI2gT0IaaaMjJppo0j1TzRT9RPSbSe1Tek1HpN6p6npMQBp6htJozRkTDKZHqGEGJ6i6gEFeWGoXbLW07vtfMQmfxtP1eltr5lM5HO+PhZWslPbqu6zP701m+026t7ryLH/70PfMR0esddjXR3rvtiJQuXf0ajpU71e98O3MDHFo3Ky8XnKSHfO7781O8UtdKTKXemHzUYl3r0BnJ4swruUDwcUKPVHRhkEoyMAEGF0MyBLKfJV0aflXmNZOvsI2W8FL8HggoPdQYO+ZnxTO/3I445An/Kg6DH4ItDyI09/O7xA50cTpyDnEETlmGp0l2vlf2CIIrU4H3yAM3dN5ZhlKTAxhv3hzL0zZOy0EwAxGNvpfD86ZUNCC96/LsZsohLBw5J/xSijazponfeHWjOJD8Lpf25BI7piEYMAskw/8MPseHmouDabRJA9vVfL+u8CVFkdc2NSOqoZGYBmQrGjp/65a0sS5ctn7c4nlSfTe+H8KN2VwF9dxfvfDshI2GbzQGivuCkC26i0eUBMMCfc+u2qAzZtyhI4TELdm7SS4TC1jC9kjeaNW2WadE0UlTCQYBtRUlVQRYa8MQsNIiGURzodKoqUFLD2lSkVq1fTzssrppfQQIQ0TXijMmlk0k8IlstHKZTAbM95qaYgmo4tU1rZadOYrZcdsfObzs1VBzA3QQEPOTIPTI0pQQB7VCDsg8qKN4ZcW1FqpzWmUa3Kota1VWvbetkZ8MTKVRWOyy2bEyV2s1nYpa7FKz1qCzJrGJXNDjJ/Ea1upR7nPc1GOtRqrQDMJStCJ7dVVVVpLSSS9nyLWrjFVq65jhe7bcuzbq2HgXt9zeURzh4WtaPPIS1TY2a+mww4lqyyqm6kqSi9VqySTNeqquJaxjNa5anMqqpMcKrLAKqqqm8M1fLqWxkbojn6IEx0al/7jON4ftOz5v7HpiRZpJaUGr+DPkVovtyfxOUGNe+84rTtHys/seNwMVoWfmaWTmqNEi/fjE2gsm3y4RXjG2QGkmrSIpjiTg4hU1TVRSN1SV2QG2oyNFgYiDFAajQRiRZgAUwSFLxWUbqJUEiTaJBYgG0ugpGY9pbcjpyt/2XXrMsfGSlV7KhPCnlA0Ot3PyPQ8p97XaoRoauzxPE8z7b4exdt78iQPDxg8SyD8NoQRIQuZFz3zt9jtLE575TC4xn1eIYPsaYbPrtanx+LxMKug+bhyaBGqDNkAcYxpMVmenIPbCFt6WbY2OgjTBv+XJsMFGe+fUaKAwG5F3TpNJWaF1dzYxst1ojBW1kJGzjZKw0waRdpZMBatB2lsNRqEypzJwu3ZU2tRrHr17Uen2bupO1Ozn7PP4ty5yuJq+XK0Y7eLP1ezm5vJ5WQ4vtrl11ZTU1XV7eNzOPm0/NwXVSADGhwa7oDgUtcamvETASM98dMSKAOETI1XZ3EwBHVaU9bixD8xioaE2luvvQRSSFxbEQt/N/0RAxWGrGHNdJIswV9Dl8SQUjVF9MIKxATW66aEJHftLwdGCKBLcGJLxWjFOyfYtC50m9jfu3OSpRdmSKpsPFfJZaoBFERWmRAqDZixbngTF4JDMGhHpNHH8CA7bSrzGYpK3m7Ft7VnKeHgwyRUSO48CFhK0bWLPW7BC4XgLlTv6sqjMYtHfZVgGAQPWMpIqMa726skqs0P1dI2KtHDOSnrYhgbqxLsYudYW3aw3mZxclgdOyUT0Z8aXH5UMniZ8QozWO2rM8QsYirEH7XY1VhTkpSeElzhpLLaRHZVBxSv2B6tiYKYgGfNgY6sFoIBirMEY3pyQmUrJopNFqYVbn/F+tL6fuyOu/LAmG/5iAu7miTPjvq9Ov8fcAD7ju7YoMnFILHmKHLTE9Hy3sCnEH/kKHlrefnuWSf4ag4wi7Uratqswk+Qr4/lkJ/WuFqrOBj2Wy0EpwhGdLKSa6Oa1pBHPXDdpRO3Ln4em5R/DZFnhi/mWX7hhptd8CweLtRZrj8Xz7LkNa+H4lLCvhYWXhNcdq7XBnktug8rUrYGfKv7yoHzu5ztjYXxlMWhfb7ae2/uLWpSlKYta1rUpi2Mc17nvY5zVLta+WGWWOfV7qGoN68swpHGlMvYlO9RjpwNpheflgSLJkpRkAJ5CeRQKISDP6vUm6GR7y1d2sFdXq9H3XG/clS7/6qXFaN5G0v72rxbpjAgDGPLGM6JHzSAPAdNBAD5zmPGkY5EV79Gjf/HnH7f2efmN6qs/F1hZuLq1WZn+H3+0wYMGDBgrXLp1euXLl3h/1n/i9WhnJChm8uDLhy4L+W/ex38WLBix2bNmxHjxo2tfv6C0mE6wBbCA5UCpslCRTg34Upyox0yMp08mR29HMdMZC1ndrt3GGTC1QjPF8s5y+J32vmxzMqvkUfHvLa5xaPaXgNrILGgBCUDYwWnFetVp0qNCvbe51FVqK7RrScNbtatCzUdTOxAxYtFq5bt27lzHjxzdM8cTaobdqM2ixsj5mNVquEnMa0ILFSTJi6+vNx5tfXeQ4uvPn06FChT3NjYqVKl/YhUIaV37SBPhQ4G7ubu7s7m7nXPQYVBge4+j64WWl0BfTuMofN/7wGoZgNdqanfd3Bed5/HV6H4K+go1YUFiG66gsQqm+xewYe32NVqtq9FmWZGfzNpbX9H8zWxxC/A4f5DVMjPa54LEarxnLxcNHTf1qVw9es5B7q1knYu2WS6dc2HvvOh0HPKBlCgjIyHXSf1qiJAiP0+hEdDofqcrko/WkQ2jk8yqR0u1/CFqc+AE0MEtRdNqjBBwhBBwhBCiPUnz3X8rUvYm2MvkfWpUvtxmjKnTSob371ChI++tPn/1S3E6dFVmGud2ZM+VJkwYkT7WopFg3oowm9pGYZF/RqLffP6sFHxaNmhMZyKeHRprNaqjXTofVps4QH9SlLoNImT9KkBVDBmfx0XknbLm9PPj4S0bvawjjJIu0f2oAxobEHvPed5JvoJ1CMtxZ9smn9RaKEAAAI6iWGJH9VcFMXJKkQWnylpTeWQ9mlTafxAqRbbbcoNq/buQkLR5Wvbe39GH1tzBAvPavwc8E4MGL37QAVJfm4aUUklWfNieoUEiBpYsC7SZA+v9eNQjcqfDyJse9xviyV6J5pPZ+dcTq88fmI7bkTBxxzbaD21HD0gu/EEVDpxAr8FTeeFJgEGQ78uSpINU/nyySbsPZAa1sxUgwhZAYyLWaqxeI2xei8rArvAXaZ5oYY2ENGeHAnPIE54qroScjzRKeKV6NR9SX6Vl5e5et/Lp/Jqun6/r+uLSenTFOSk1MzDWXllEnJSPqyUjIerHz0fHRsZ14uKY1vr9Wu1fWTfi5Hpa/pbPo8n0Y7lehyvQvHXL9C67/O8PneLwNHhMQ6C7AMfAIwQNhnMrk72+dUjzAI5HB6cFTqAnC8kySlinOc9TXeN1Gtcs4wjBEYvc5znNazmNa9sIN91rWta9zmsYxjGMYxjF/W+BTxbwoupJN0rrFmF3gd2wL1mjf4LQ5KA/foEZExJSMDURUT7QNLGKHsV2bB4V8rXTFWG/i647PM7MezzezZvI15avLZ5b2zy3gg8i3jhxiXIxLrEu8RriOcS9xL7EpsT2Xjx48zMXEnsP7dDV7ubHjw4L+UlRfmzLtLv6jhn3lRtibYsTZ02wd4xkUwu3jq47uM7mmJcuQfxr1uQUOBo2vqTvZbfQ/V8yn9n9b9fWg8Ti8bqRXu9c4koWqh2hFHRvfYndKBwXWBdU2c47TSVvqWFeosVayiVYb7o1HstWcrJSCap8o/tVEn9qq3q2iYKpV4JZjfMVC3kD0sHpU+T6/pyj+F6eFN2rj2bPF3mhx9/QpE0t+Swsb8OGaTxtRfBieKYqjkTG7EnL4saZzeHlc7m8jj8Ou2l89s1bSZ0unMS96vQq0OqzQ0Z4YrXu3gv1r16XKbYYZI3GDs2LCllMKAUAlygE/D4PQ8DsnQdBwDDorlk39hfqWV1+v0MULpabu1M+yDTxAvgvg0w2qwEwwFgYAX4Xa1btYt0XAthbLRaC0i0rKtIdotN2gtBFBiKIoihX1lju68LxOtD8TxuCJwRfGieK2RFVP1sUTZMYRtmbI4kmtJkzhdGzFYzA0NDRyeSXILkkY5I5I5ItlSGYg5YlE42PK18L12vG9Kvpdf7J++eorvNwXt0o9xrzeXtunuVmhItx8niJwnQ7o9MJCDFnsP2NfDZfEhs/2IfN2uZe2JV4PPkXg3Uyadm+KGxgVpmJ0FBpyOxfwo6rv/TivFRjJjLjzTcYqEah7uHkJZnH/0fwGhSD+QXKEGdydG/dOh8S3d7VIytkXvVz0Jf4DPL8/LKxg0dX2N+Z2ZCvSqWFsFJ1RyX1mPi4yZ9dHDt0d2QV3Gfn6GLft8G80ay7slxpECJND+Pllo4phmUOgHkfZXjLKD39bzvqNm3sRiwUH08+eMpQf0e/vfA3AdG/VVVKkBsTcaY2xPE2sgSLFxejJ0sXAnOMWRqHA1Czs6Sy4N1Y3DAAyKKNPGp5IIGKWhN9nqlSpQrAytSMj5SWls2i+T1vu4XPAglKpZZYyNWrVq1Ks8HMDDihnh2q8G78b38iJQwqiacUpL7Ov9LTwMCfxPfePo2Av1IMaYwsBYCDJmlN1vK8rysEKgYvGhW1gSgucFgMNSSm8xqvjz7X30FdgwqAwxby6n6Uy1MWFAZloqDdtyXCbi5shyO05U3MlR2WgsQXLFidROXDgiK2XHuRbXUvL0lvYV6GwyMzAK8V3TSFAjQIGJtGim6EL4uhAlKsVisXhYAywLRbkc0aYZYXUKn1cFApQc+o4C+KiFRCoD9xAMDLB5tXT1Jz9S+4VVVUVQ679+9t+a5zeI52hs9nb4mLteCWZyCO0V0WTLLB3gV4hkrAwOycStZWbNmbhOc3Kp3pednaC4U0OmimimigNeEAzqi5FKiiaqZYMYZg0geYEDIyNzNm2+CGYPZ2XFzqqVUq6Nr7HAg0YQEFsLoYCz6JheBGTk9LpZGRn7JwEiFQEi6JqG1Z6tSrduCpqkFyZU+RdXCS+vosfhhIVKlSKvFOMGNVmKcIMG03Xoi1QbClYpy1r1WmlSYqgQYNpuYJm6cLbOHq5/N1vGz4hVazGtwyuSMG02qiSts1zabbTpttulnpts1NTUtqcwOSwbBsM0e2ZpFJFGD4W5DJg2DYHQ1J0Jm3+f6rLG6SNCWLQ2htRJGDYNoJWhsGwtWsy3LNNblA1VSkY2Nq1SiTsbGxUMGwbCvXjJrQoC3OkStDYm0V6VeSvNMCUWNpse36/vvI7vq9316XZcqHQdl1KlTu6tWXq4IQAmJiYvNwYPB8mzi2jtH1TtWm+VeGC0B4dZP8+2B2bg3vWvgYmJIpSKMSjEDBgx3hwk4G0HeAygPASGzdNT5ogGlugZwIbRmeWMxuI9T1GNjY3kCoD13hFk3YLGAGrG0cLktjburN3Su02nCwMoBd3koB6Xn/T+fYPfb/pebyP2m/xfW9jr+vqqqqqtKLWtay83ZURXkqLs8IO8cqCQpzn8N9Z+/vGMfStEgo+s2PsQz+P7QCgOOYgJhYSHi4O48ik03JG22aFwrfFERxlcyZ01YK3g1y+BfsOSkphtMtpqBaDUyM/Ojc3jZ2fo4OBeub/Qz6Shnrilo6HPpqWk0Ken0cLEowJ6Zk4j18Z+0LbIvb+ziuBptPsVu9ZvlG1u6CmAIvRIxiqqgrA4FYgjhk0Qi26/ZV6CghkPFfCfzvzw5OV4cV+0yWpX8ykcsytdzP27Fm3PvX8FDyYTpz7lCvKuodMEVFRjiS1WQZtDlhn/F+8aP0P8//f8f8i3n9zeq7mpBJrkkGwr2aLDhKikTpiRZiQVGAiM/KV54z44GT18cPSIhPmOEBDYpLehtwlxxlGW6sODkrFnAgtjicSWlks3IlOfHTGQMR48xI2tr4S81tTTu3vCvX+wm12+2ZNubNBEARgRGBGAMA/S4Zj7+dX19zFhxYUGY8SzixkqMJLK13nlNIW7qECA/ZZdgpzu3luGJYLTbs+Vmjsxkd5LCrYSEL+Yq73F6/R3WBTrWW3XhhYRItWQbGnaeFqFoJ7PS8z8Sq2bTbORmLEU1CwaGMM8bLuRPmY06LxGXOYuzSZmLJidFyAlFD0pl7S1wjEzF6+YNCo2zo8BO17KahspvnEzF2F5RnNlVRg2ucgVImCmLKAJmQTsiCcZ4oL1SIWELmo0GpSHRiZA7nxwXvZc3xMwZzDnZxD3NeRBfrEGfQUQjGJmMpEqzEH8gh7ye2Q/FdAzcaH3kHeRNAUwPl2wXvYqvkMIegYJ4jMrWWtE11NNDVMENb55kOyn9yC9yBQ2ZxEDjSlEsWxMfYBb9HTItHOnCBRROkjSg5oYiNwWTGsZXBF7ifhkqSjRJiEF6Q1NAHpQc16EReZlYClLQi9uYm1DoPDnPQiga8zQ6t79mb3wQibxCJnFMVirh2xlrWsspOEnbRfGqJzx8t1u2bHgs7mr8zP4lXtfb+zwPg827lbGxnrjdx+x9v2vt8fdwPqoN3vNxY2W63O53WkgbzeZJ9nYGImJiZUqZw8yZiZWVICYf/Ck3MrjLuHAbwQcGBa1LQDQoe+QX0FMYZmjnudzvfIkVHxgBzJPgImcIuDyB++DADnOcaEOusvOSZFq78yDw54OEHCHu/WMiHq/QaJ6VMpkCzTo/sitgKDDhJeEHHysm5LlcPhZ2bobXQ2NbNzU22m6utkK20uLW0s6apo6Woqqqpbt6qqs7WTtqW1uKq4uqW6oLq6t6m5cXVzc3UvLS96JUJfkS2oRPmVSDLFA1Ruy0p0SSdEIwwwxqe6ITF6xfOoicJ0OyY3NO7625RpKAoXUXotJThuu5yYshMIqpJkIKBNk7952vDfbiyUd8pfVV9T5X8cXh+CPWnjwhD5foiGRi5T3P/m/SdV9Ee4n1IPf9cfByGMZ7fzlKq9j5lS1rkr5+4WpeVMG36BsWpetYWtdpQrT6738y9baNJkqpxcJfT9uIjCD4PY4mDfJTMlBzpLWse1BKWtaLZKUrkD1DNCT050tF89VRRSW2BCWq0vbcBKdS78nzldbqVkt/z8z5LPPQZHQfp82mmxzYs86QmSmkekA0M5YyKAO0ICXJrFChuuqgYDhWlnJZkTC1dLR8Pi5yir9BVV56yv+jis5hfXpPd//f4+09VM3xg9gJ7ML2GHDZ7OQZevODmHHevdz8f062T1OV3+HxH9iN6nHswv0JfJGJpORklX6161AMUROJDR8acTKSJ+f/nFLlsxGUhCHA4HA4FbrIrh9YW5cELuU4IatEIbkRZ64i7RG5jGuwTkbwm6ZYCV8Xt/ftWrMbEaQptCq35WOGVnIK7VSf/uc53ypTgFp2LGaVmzmF7vuznfKc9Uv3s58Upz2paPw//KUnPbylGMcOHEjBze+1dXIyc7a7PZxkk1atbSXl1/c+KEaCBP22YtjY2lzF2hhOV3MV6/nwsGxfoWEfYCFhb3X42Dg6GfxPcdvze3zuds6LuzpyYNjTi2NXUx2enXsp6SfEsl3xJt3LdoXu21F8iC13V7o1bpeCZYzpVmqeqn1NaNWwV3VVot2LW7DLVEHl/fGv36SDzg/JFW2H8bZ4W13HH8PVX4rW3zdJJQqGa1oizs3YiSqKMYmxjTTERg2AMbY2kkqBAxoqKgDEY8mEjmMkYwX/N0/l835rBjYeXUVFQtjCysDIsoitUa6gGASJOvI7ghGhx8R7jM/H6ei9D2uDv9Ggv9itQW3pgc3Qe7A0i1Wg2mhs+dZiEAHE6Z8KUlHknxcLEkMSX8O+7+h/Gx12uHh/y895iE8oM+j+dNaMZjD0d7h6W9yMNxW3mRoaeXk79NpsNJdmQNxc5jBsJoiHG40yJeVl5aJknxPL+kpU+gqVSquVD3/E9/33vz354e+b3ze+b9wHwc9rme21i1ep8rhamntvaxeF8vz9XiZ/0fgwfuj8OBZWX2z/yxA7d3Lt27Adur4BX9R3hgKjAI35hfmH3jBFP1GeBQNr3wsr+XBPF3C+vYzEUtdu0FRDoIdBDAb6sArBC7PzelzIVzxY5UJyFC4uerd4B4taMNuk46Ge9+ueIHjxA8QPAHhQZ/AoI04EJd9gg5Fz7dWgBQIfZ+yBWA+z9j3IFZ+xdr/52LFi1mdUC/w/q/ywN7Sia1l3PoAmb5IHujVITlaAFFVBC1RIqs0iokKCzTIvJySkXIUD3beEm0/FWG6hgnJCEQhKAQv5EMMff/Fa/0h36d9iDo2Up1K+RmcE2I0IhCIQgFjgARDwAYCFfABgAwYGNvc9N829T+ZMCEIhnuhCDQf2JH+lyPDjw48z60khJISSDAAqGm8Q1jC5FfIUZwH7U8hPngTwJ8/+T6v2q39/4t4O305g97Z5Gn+BRCsycc6dObzUqygUoEaoKUQlJxYt5tIWbdrwbatT4yxxLnQY8dG5y3ODZq40hqXko3pqRjJQaN8lBuv379n9ZS61Wb95U7yxbyFuFy8xguquZEboWi2tCriFHkbF9Szt3L9/7tfLxNfMkNlgbfxU1Myj8PHaMXRdAY2OnMa0Y7MzLx8gL56rWUxZSQlU5eZRhURVZUoFTjEU8ipEKX9a0+3Qt25NZz+5TdFNmTJMOA7BPwT8E/J+9f7v9eba2rLDCnADfsIp23/QcqpbRasKE0nTrdKjRSVod06efb/jx/9mH3241lpHWZwoyeIQRGSocY2ylzLy0l3QsQ0SzHdLTORokAS5cxACJema4ZKgKzQZHNwzp076fyTEqhrTMsalRo1aU+kd8rBpXRTVFNSnOQVAUVkFRVoygJ0s55kiZOnLKEpOMjnOXE1hB1N/ahW1v7NLaN9rX4N+13eAuDtVFNqoptMb2tm+r3P+3/REHv5ROzZtLQCzAsgKMD907drFi4/8llNOsJ199BiBcPlwQBXDMBmAjkHra25ubF3c0flmN3d5MTMmAZBP4dWfNe/I15UYCLFMA1ooEUkFBivdKbG7xnjK2MLY/y1DJUyAZMiAJ8ZAMgcmQZMo//m3WP2LdT+I07GrGAjNHz4zexDe91rarxdw6dOj4rtTpqST6iYZo6mXVGtU0qChYUElMY6Xd/hukKsFh9BOqxBVUTNfwlFIPVhpStGbxIURCIRxNhMI4sVIixTjxZfTtWHjeJCjnemQ5MJkspDjpTFjx0pWcWmkePIQiOch8mMciQkR5ByJEiOblixYksOnDWHWKHCiTAGbN48od9XwXbcF69qgSJjyk2s3QNtjWdOnUbWX06c8phiKwwww1gYwJzADlyhzTwwHz5suuzfRCbtgObxn9KzSet27d7cbL7FfJn5vBxVMd1rt63FZvHjyGT3V3rvd6cvGVV6K3Wy27/T4PZ/On4eVsXbuxsX73/TbZ21jHkbuMd1hyCz87Qkmc5xj0VbM1rW9ddfjNg97DJkt2YtrVnCO7du3b9u8b1Y8ePQgDDShBCOTeA/olxtZlHZs/6GP52jRtIpyZMTrvD2TRJeO3dN06dR05tnU9dlxckcSzenyRlPn2qVKlQ673ucvN6WFmi5Rud3zMtaFs4jlOb2r/Cy/259f0dXhrmzTat2/r29xVi/ymJahs3TnJjqNYxnCkrytiE4WE3avH8SzbYMGK7KysrKyMFzI8WT2JXfxNi9Dh7MpEyTDFhfsPp7DDDDDDHhxakiZAcuXDhw4cOHHh+HRcNraBNDwTazm25WZGyZVpcmtcWrLyqy7ho0aSLt3wIctvL+e6SHTqZM5NG9KlSnMVu3x04jEKF4Ub4DRo/ftIzSNhv8rwOXNf86A65+zCn3YnNWWWWrs4KjN1iPet57nvDVvM/saNKPp5nkeBxmta2Vjh+ZCHiyxL6O8a02MZf0ux4G2uu0K2qUlHVx/IStfg3cC14+M3BoXtFFlrYw6C97Cxv5Rr6PeKYxDM32cMKdtLrrr/WXXYq2pXJ6PQjWNqvLlzu7W5nP7rupuVQSBw8S/xmKxyjFN0hAgtN/cLB9YVHxvrS3t339b2wp7rjZqRdABAKrB5emXouVjNdRVZ5J7Ysv1kJb8akf0GFjmvGgC9D90ykhL3GG6Uj4TQcOBu7XaWmnc23BpXtJqdVsuZw/ireFbXvbbevv1fYcZrHxagESc4ikQCMK5QJHuv/ud3RrjXqYPWaEeT0ICpsEtNoSOv30EVxoWNxT+v+l+l9pQXuGDUb9o3fZN4wuF5wcGiLBFkYxjGMYwlog3oiNliRwGg27KCPt+Tm+d0fnQ5kNNUU5/0rMHZYgNVhugDbEeTu+R1vxroR8/GJBtbRzBEFRZoDbXGZ0DNjEjCEJBGU0krLQgnaX8v3/s5WVlczLy8vLx8u92HOLL/VgrbLjEG4abFCcwTaQwpULU7LkVtPNxP3aDVz++c7hICAgSlL7TxW8blKRoqQ4OEXiMBHkE39UnUJ76FCEIQhCD3uaxaqgALxgADl/qZ4GeX+JCBrkEIYQBY5oSyfAaXaeTEH5zQsepxaEkdTNAPn8cLpjOODfZ+h6O9h+X/Yx/M+f/b/S3EtbzGht9OAimINl9Htj0A4cpWAXB9ayr9Wv+z1fuU5a93Z2dvb2ejz3oF2CgAFDiPU351/Fi+1jjgPyMzDRTVdpAYY1ikMVRSV1stlE/k7+H2+3+/m+9+7/F1vvalMuMBH5nK8L+PHWRNnuhoDhtIwNuDgBy+ZzftafjbOMY+Ln5+fNNNz089Xjr6ius1f/JS/96lTU1ae6lalVkOsq+kgQZVYQtzsPiXJeGP+Ah0IXl5eXl5eXl0hK7awU1npgcfo6Wn+C5ct6+kkgqsXZYvo+QPyCfQngri4JB6fRgkZ2I4Jvo20qRp06NUkBUb2BoZ/V/BEcSEYV5VO1XTCsxFFE9qopQKGAZmB4xgn3G568V1LqOXLz7nc/gwcj8HrygQoEAowBwF+fzfvHec4o7MgZ2R/zjYYFJrHE0d9+/e1/cfv9KuUCXVqwPv9YIRv74v1QSik8FKBhvCaolcBUdAhR28Jmj+SfS1+v8ozWvVuvwXUmFua1V1+362jIXd+nADhtE7C6YbanBEjAm1IF8wJ3M2DbMGYZly6C3w8KpmD4WaBbNEYHCN4pjoYXy0Gi3XGK7DvvChlaGQL3GpSw34LDdyr2HvPaqkWaCzkIczAgDgMMzWNkhkyUHUYJCqZLLyODkcnTIxyonG43G42/v6mpTsLL9ny5mUaKhAIEgIQtcihkKamps2S0NBUrUtUJS5C0BKyTyfDUZ5mZ3m5mnxFDfSJhjcKSfVwLV8tZFMwEnaPQ1fXX4Xh+I0grghCLwHlc1RyBAVJko4MeJ1Nrg2X8Z/4nV5/Hq6IlOTweTJ8diZz+WkRZMbe36+91+uvA56Av0Js5vurFq51nTrV4uxr29jYutwMVBBdVx1ePUyvzJktCNBDfKlgchhKxdVh1eZA2XRCvPIsyx3kUEjB1yCA/CDtPh2v4/gSG10iDOHBFMaR5HlV8e77i1OHuml1ep1MriY2FOuYdEYr90gi49/hSIR5Y5RUlKbIIDx+n1q3I4N/ixadWZh0v913HjRb7AyFM1jHlfhSTmX0MSjtJOpprKyw2tZdUV/YTeXq5fzYvG4eZvP+eHv+H/HTpQKXa3mskO0YGJnwDatHZA1rujnRNntiFeHBiFNpGb1tbEEoyGivmGNs0mkwDOMDv+FUka8bxi9MpEzsdMIO0EFg4SK2IEHvTISFcxXXot0erIRHWEkzVOTwKriAExigPSHKEYwa4hhb4fp//ls4Hi4yCSkqrVhhWJLWivYLFlc5KKUnSlOQ0DqG5jPEUPCMSMF2rXOuq7O1L4zuKvtX1cfkZ7B97sTSrelNJJMg8/umGHviagBfyUdHydwlKU4yfBVgW70H9p7mwADfX2m1ULr3+BCC1q6JWnASwLSA1qUlv/mIDWoBavBvpHhFPspce42vCuZOPb0cK+X1VDT6OHo4miNHF0cQS0JH4waztTjZmPmRuZk28hnz8/P2VfPT09TU1BQUGZc3Le2uICVuj0IoqU7q+vqh0+3uWpYXmXXPjG5ZucrHeX2VkYzrKycjLy8vLy5C5cOby0s8yyuXFfXVtZZ1FPTUs7Vz11V0eHdWrelFdBnMbIhnF5CwJ2FCofUTwJobFLMHie1GLTNFRW36+V5mU4eY4BG9YTWrAUp6Fy3bNmzNk1tXEK4cbCC6heepSlJwTV78/x8n7LGYrcVv3W/exnvQ7/q86qm2bNm5R751KqTCqjl3xxqm1Asqwy1vjdf7Cjnrm8H1W5LpSTyfqsqXUWb7OgyynoNBBqJuFqvZi+FzWyM0wuX5dI+fK6yId+Hoe43fwryj00LVB9gYBi8nSAsN49EGZR0FfkZ0PhPTKEzQP25w0IJyKtFOScIxvjgQp6Thk2/VSHEWd5ORc9Yrndm16PoQnh/B6HzSk2EStWuu7LJ7Hft/jdW3TOwleNQDXbU1oPvbHio8YPhrWVca4jB0ES9/RukSe5xdyiCs7Q1gMbnhFaWz9OnAVL1EUUqkmZC/RJ1xWqgshbV4VWll713ZFwx8MM6xWkFk9FU0aOH68nmr17EL0O+FkBByXkjcME4cQyuGO0+MzVySAY75IjmIZkG8K/bHf2ezDi+jLaiBJQMDuelwcn/7wqjgqusTAbMzammkWkqk2MmRz0ZkyUqrsG+nyjJ4qqWH3Fyd6ZQkYWQ5Gn+E3coJzR+HX0CXT5Sq9MmO5WblkvQHLV6ZLbkK4BLuOvLTjJZAHm6jvIS1WvlJTwF6KuqS2TIp3BK4aKnbJVigpjb1iZeZ5HbJTtv2mazECDatI9v2iQtq/m8tdCQDaxnfZBarV5gFtW0ZWBFZMOqUGTIKQY195QCBh5LOaQPHp39Go7B7bmB8zVXuAoT0YrwayZMMCGHGZxJEBvCqKBTIctgD4WWWzwGvX7yUfFRkyjBN2+vUcP0/QXy3H/ZEVn6Kjw6q78Z9k4LY2fHN/npZyfaLUw2GnJ2eje4rKO/Qezxvuf0f0Zhstz/iYbLNM6INsaTaJTLnNn+Ms2KPgyUw+K0GaeWH0p+CMJWhI0jG2FcDPlMnZEK9mAtAmlkLlJBSWZYlvlgLJccqs96TGMAtbY/OCFgKq2/NQ9BpsD4mt0Ld4aiTSsCo2PfaCEJUQWZC5AVBN7gsPFhYFwIaQ4Uo2TgkucfianS4RtEwS9Ztm0SkseqTeHs8RvzqCa/FjlQV5wIWpP7ZAwjO+TQGhEyZCC9o4PibU5O3V5U4Vrmq4qSlX/ud/v9+SjoaK0Z3leRoZmXk3l733Tzg8Hv5Ndi6mdk7XF1OJ3PI53e7ut39byN457/O2Zo0yQqgARhF27o0W7dvRo0aL169o0aNGHDhmyo82XJmzJc2bNmzM+TJkuZrWTDfu5MWHBkx48ePHkyZs2jRowxuZ7/n7Sg/4rLQt5T/zxO5zj8yj5KyzbmEhCAjH/B2nn1ZfY7e3Gn7iav2Rx301Y7lV+nIyMVCsqkYcpNxG0qZT52OcxLpRJBaggjLARSsVJCGakrrOlVhXlOUk4AfZzPMzq1cfrhOBIw39/2rP9oCFgwz12S+XUm9hUAvASl/9zCnlDDXMIOp8X6mTMxgP5rNjLn+524/NBOgK4f2Bq/1B/pafkWzZffOGk7FSSAvdOtmwQYCkZyKKtC82+/zf5/3PvYWirHCr1Pwi8isqmPkfM8zWayW5R++s5Fwgv6QFB28/fjod9uAxSAF+WzrHUChrGqMpzrft7igc/4SgWIxiNCPaEwQTU/M9HTPM9Cr18m4H83tdn/YnwWraMBF0i9RsEbFGqq1F+jag78BKG2CpUmjfYXthG/x4lWr+VS5lS3wcezOMPsSFRg9aZDa1gqAroKZRBIe3j9QgYKJjCCZm4AOAesQ+zXLSU1JUMtDKq3s/icxqALN1HewJF4tkBACuZcADbEkT0MXv0FLegSlKMODAhSUJTMsZYGVVj46rWJO3cXwci3tFALy0CArLmqQ1voJAVMQTIfutj/tc/06m3T/g/h9EmTVCEAm0r6NHZtwf0n8WDW2W49X0EECcw66PvPGjbByt6zvFqDbfwxfaq8q5dWUxIEdVgZETg4OQlJI6yaJQlLT07PKVjGFjCrNyJ3Mvc6HQxLHSgYjL3cLebzW083O32zu7u7tb/d3dvh7WXm8ba5XJ29Cf5W3t7e3t7e3u9Lo+Ru7m5yt3k7u7zdGmqbKxstK1tb0kLA9hanVfSR/WOe03kbyVVUa3YLbky4yw2npotK+qgqmqq5KPjHyZqq2tcOK+vra9w4cOLOzpa2qb1FbVydTW1lZY2bhw4cW9vaWVhXWlnZWNpaWlxauHDhx0P6+RMcczsCBpIG8uKcpjQKRNB0aTTcjwnKOti1WRhbot2WiLsZYNC4ngwjDTacj7NuBlfP+gT7s+aepszehUikka9R/oBGm21i8qapp3kZGa0sa9zEMQxzW4TZ9tZrTn29Hp6czIJ0cmlzc/m+AIR2iUG6RGjl9H4Udwh8D5rqlOh1t98vCfWAZa673CSAJIA5hd9JhprZlDFe7TQBWO8YsOVneJDQSibCmGhKqCLV7NhGGN3TPl1r6GKBiDb4yhAEmOb2vUMr5nxsP07z4+zqZ4toZfhWIx0IIJmAYGmb/1HERW9bnv03CxC/F6/loAxqQgG3lH/rzJXfpWiyP+tceP2/Z7X9oyJEWDGEjEt6BlQWvF/x0ZdZ4Psd3usY58AiWMnRJhF37nKXgWxKzLEMn/pUmMetAmXMwv0cj5MxRvs38UQkZTV7wYhIPRj2EgwmYb7uvQ/w/U0r3Auj46x1cKfYRWc9a6s0v14VloI+7uW1a7vna3oyERSdtbF5cNi3po2p3mb8E1NS7GWps1RkYh31SfPVenjm/ux8Cxo0WA6rvBEu52O12u4u61zmyPWyeh0MyzxWsz16Gwp6OWmuvuX+7h0t11vN8yz63V83sXWv1ex2Ox2Or2/N7PX7fX7XZ7fa7et2+73aa6b//qOvgP2i+T/FLGaxOIa3lb8HLcz33bD/p6NqcPhm96q4be7Oq+3z9q/ae3rqKgiPGrrLWzeRu7+7u5K7u7uSv7+/vYu9dX8xfunTp/d38rTN27epqqysrcOvsbG2ur2/pry+v3N66v3Tp06dYGBgYOFh4nVodPC6E+b2en3qf3aXzDIVlbi7NSBmdgzQh7vcytx9Pt77mOeR1G+zlnU7W0gZRtitukAisJEZZNHKQYpDKJJQkkEhkkkiiwSXl3+4vdWPfu9UfhOqo+e6i86faciUbz86H2750/sv4D+VPi9cl8ofixVlN5iA3omSwDT85QNMuBGaXZAgBhKiH3oxE8tjICREdort1lhv4LcIVUP73P+ehiOdu87ic7X3dqqYDm8uZ6Nb51fWN42lpKGf3eew3C737/TuerUVGsyfR9+UWGi3DEjkdvqV/OxWcj9Rr/XCAY8Wr+hmwEo0SWhJbqpQF233K6KwCAgLN9u+mga8IwCIRIEQOdP/j2tBs+e8vXr/OyhkkYGC4uoS8gAOyGTgRXq+2B6Tn+LnBF6qiVKLBfCILUdblnRfY1COJ9SH3gzkkrdrwwDe1ZjhhoGqSOJF2/tdmiuBDW16rODepptYbsDnZBsRJDW+n3/qSVGKwyh/d+h6H7UldmX3FEdxuIEzBssDG9dwGNjDmqHaUiDYcBDOHIF6+1Pga5E/cjc7XX5HY2evox+7rPjKl7Ow97UV2uzxdbtbWz5VB1N3cu/M8npU/U8vyqWU6k91Op6fp6ur8L4X5nhb3w/h+92eDWGrvWkcqfSpUr2DA+dvnj56+rakDVt28l3NmxYsWeVkyaufW01KlSxYsWdTJhz582TFn1M2XLm1M+XRo062tyejq9L6XwnX5Hzvp+D0Pe/SNeqHqhKqjqU6vd/M+hatfe5iPHawRmk9dehINdBnhA0SlkOBzmvTD7+d0+dJJj/HqeR6HvfrvZHow36PHay1V7fEpjbbbGNjG2MzQ4n09dL+B8Wdrjk9dDIvq/zm2Ub794fsfcjGQJ23X1l2wzmknhoXHamnbabVKlHuacqGbFA6D95P3IaBoJbo9mC8vOzkyPnqPyRDqbdvb9q/TGh60L5/H6vV6sFCRIlIkSouEhFYVgKCnpUmC9bWZNlEA7bMAiSobLcNHjm4VwKy46xBX9jxf0OvKEtlkPtMIDpvEaUWmPN7/2Yikb7/Ujd+LAUrn1qAXeK3W7elYBDumpjGQA3XftwKwZjkoV3amhVBaPtn+Vk/lfVvuWrhq3cOVcOs7v1fX/Wr+p9iMBb9VCrm6YMS0GJSUIDIIRocqJSSDgAGYgAqUGWUoohQh6p/Xb6+uj5Z2/c0aEFXyzvgeyRyWAYRz5Vl87UzCjYTJBumG6CTeBw8XMytSZUKyjQYDV3AbBjATYBJrfPjoZeYTwU/pgXsNhtvRD06Xqf36dVqs0PXk1WyJvTyHazthNzPxLhupQ/e9VB9TkaEjRkjH7kDew1DtMEYI8BJiuZWRWoHfUitDssc1uL4NlRy97CrBlpLFqChVX4vbaV+Tc2DLJFfO5ug29n5WKC2pyaFmsa2SDmQLqtS3R9DwUvcej0flcjWseJ9NJeqqUwYSzbJFXWc69khhB8FOLx+vA+mIxCAfstTa6GUEaupHK5GD3lqJGwCJejoRtKrVi8v+WjYA+097ke4R9RlucZZV7MICNPCJJgzBg4g1kQUYpQbY3qQVFGKTzhvaXdy4P6m48Xm2uJi39JWkDRBqCTSgFYxNvmK1qK9CZ43XiARLyDgFvS3ml+lLWaLNLDiKICp4Pc97LRiwRrfd73cSIp/V+r3PM4k20aNujPDPBbL6Px7uyUO9u2e5b5VGs1u1LtdFe25Dk3Dt20bzcsT3O33OgtdpBgxd443W4G33YA3CgOLllY7EW11rj6L/zI950W6X5v6C9vma240fud13nu9GTMWfAv0hYDAAwr74PK72abPwpKlGBTQgMSMkMGKWOxszbwFrcbG2XQ1LYMSXhauNxY3rloHqgFia/h9/zbaRJ1MuokCzQibIzPN828mrNAAQiJIQHkfVO1dXEHcBGs2CNkijlmMSOWY6MUdohYgFlEiCKC9ilx0Vak6ePOLNB3myySMgDI26z2cPd15XBtfGDk9XWHCdnV6jOfK173pln7SW7awGYmOBcwMGgB45X6qCchU2r8mjTk0XxKMBNPqz0pX6t0qG+u9/6rlYrxojBzdH3dfUxfOz6nt8eAsZYjWFCChgwWANWmrLVlqWUkryLEYkZbVdrdtbZrHa2TTYL4TQYLV80HstZbXoNe9a9Br6LWE19hrZtew1itdu1tms9rbtaDXetaTW4a3bXBa37Wu38F8BrgNd018BrsGuA1qtLi7o7HPGMYxjLiTRXzBEVMpLCqsHi1Dytar6CVXtqKyr51dJJ2ZUCej6PtJZKc4BgMS6BC/GdNgeODdwNGTU4Gq0OEs3yHmw8popEyPBjzd/lz8jU7vPn2PF0wnBnp07W1rbevr69dfXGu2DLXZa9nmZ9XPag1HxqwNxOodCzw1eJbUUWMB0XB5PYl1N3vrDtV8oGpISSQlKVgWlqiAtaDOvzqgPwAJfNAFLmwoAQuZ2W+SbeOWw5w2LClo5zBhMM6KgCUjiIVlpVHBv9FE8N5FBjB5/mDG76vmeeGw/rijP/1/+l+td+jsLXLuZZgBCEMG8gixtxEYpEVRvtHxAt+2d7C+2ytQaOHS3XRaE2NCaWoA/4am6w/lfg+lU2+hWzWaSvIGJioL+JfNXlxjgNivtPHUseI15fwtXmfErwv5/+KRy1SeBh9a2dlvz2+e23M2WWN9Q4G0tliGxUuDybyjlXhzHZq29L0Rg0uuzhvUAyrJZc8KhNI48SPHkSaIHLKN2fC9cvAfB6wYACTBgygMIBg+MiGXwPB0vqJCEVKgIODbY9hCwsrVw2gfXk1Tm8cXMurV4d3nNVbj3frRPT6HGOe+Ocakc1HIYqvekqaVK37f8rzPyPx/yumbqT9HRqMOQxbH2vfdS3cphzxd0HahWnrT8/cn5WtXm2r8uJTvoiMuzG8sgZ+f4BKEgd/ncDlLVaiGIcMlGjv3r5F9HV1lnmEBt+6t6fOPufc8rZR5PtPIbcUab1fwV8BUjpHU26K7bPutyDUV+5RywGWPOkG26C0F16xf2E/2+d40h16e4o3bGmNMZhXIlZguLPtK+0wijw0gkmL3+neeIB+1TJwzJ3dhrCo7T0mgzBqQhoQFWIQu87n+FkvhgmJWlBJF11eItuaCA5+tneB5Wx8uPnkQFP2ap2Ngi8hLHOQhJhidyoglv2Yda+V0Xd7wXVYokF75dorlN2Ztum3mOiLC1lSKJNjToqpUYvsdRvT9JkCdG471KBda7W+yMkvNeW4juSIIDlnELYhSZgTbOrLXw0a3Ez2q9SwV2kWWQY22PjdrTKAhC0TGIpNNms0FMAbAUuKocYz7Ku2jDVPtGkjO8bS+xm41YGGikc76eWu5wRFQZjSKPr16dUxqfm/E+h0/W6tWsYGFaFndTKRihjBSJkZRmiDMzCQSEAlbfX752ltFgridxo/QUI53p5MWDz9ZhhqGqLrLhQgseLpB4eoobc0IPFPDLGvqHC4SRwzHdOdZPK0VolaV8DzvetxD+Ukw7mNn63MN3pXtTRghNmEhmE4NJRkVqMgpdvt+GKxwt8H4sPIp0iq3VFj6u5hGdgSgMUHBll4yJEAuMQXeSAH1oIDHMi12bTQgvHTwiIBizH+z7rev+t96nu7bMNtXqj0ZdIFukQEEOT5XAF3wayN+bSExKEKJSlCTJqCrHeQcIUUllSGYyMIFh3wzjRQErzWwpS48vFyb71r63dbyW3da5HHzxZ9lZ7GNJp3kCCtWXJr74UbGLW8H3nZ5erz+X0el+NhVL/TXjPifY77/mJEMFOWhMwoCZEQMiqJCI4Zm4DrJNmh6aipphVpU+SiCJqAxggopZUnJ8n3trNp0du8xi1rFaRgoognai0Eb5qRrG1RxK2pSGYZ5u6756tKZUDCGu83UguZiSJfo9IyANh71pKI/N97QkikwGmCbQDaExptIjEiMTY2NhGB8xpL5bCmkm2wbSQqjEbFiL5o+x/jgio0ftsRU8qCJmjy2jFaRdggya1nTBts1B6b6ua+WEsSMQYtRzcL8h8Ar8HxNtHZd+I3xGzhrhq3i7xyw7nmDuRtuSSB0IYdWgnJnv6nw9PNvEto2MZewRBiQ6apxC/rwUQchCKOgFHEl6HQD9yf729p/OaNlmEzI17TE2NuWrNLKK5XhFJTwFPHaRItHtvJGLt0TbvQoXbXR9WtSFgNFQ2mzj0lp6ZDweG8qZmcB979D8hOdDdFZq21iwZihUwuBXQ409jHqsd/P40OXbU8a/hwIqbKbKbKbKbKbKbKbItkWyys1o2sIBcrZdMLkbdmGLamt04KifSoKVJkymQSgCSSglzS0NMUD6EKDC5b57xX/MgzKK1X/W+kC9EhPoCSIrhqDTagwL0+LNgiSUjD5f90+N9Pwz8raSynLhLKazf+YfEsc0PcInTEh7Bzg7g52qtcnVYWFhYPf5/i4HiWY0HDCOMJyW/KQMBElF4crjUaIaEGVNqjxe23zk3amA09Fwtcr3esyGDRidPkkSSGMgsrVf6VOG9UPV5ie9wafDdWJgAbrtaulQXfO+qZcOuQHlrNo1UmY+BBv76N/JjfwI38mN/BjfcRvsRvke/pv4M42rzzqNHORXtogV7aIEuFQngfkLTnnGri7vEKnLHUdVQ7qgC88USAiAgiSDDGhsBxCzfygd0fkNUcIXxod3FfSD6X7EUeN010HXLcEhqc0OyYWBEjChDMKdMkdQgrHaSFmTPRT04lYqoDVPNIdPo/Xm8ualsdfsIl/KB5YMVphtMNd7FE7V47aaNdS8FSTcbHsTtp1qse7AL2/UlBhN/D7qpl2NYDgB2CRre3fu9PD2cNHddb3asIoplGvtwO4oPJUTHidtDlGQIqjmA6Iui2e8sdXrKjr8KqoRhxZYoxXL8wRQRuyMWKRiuyjk86xGOw37RnwNWHggJhZrQoHq4uFgRMZHaVWqDA47yxcpLOWnTiKGDXwadrk8r1vPzaPWdHTuaLQdbvBIienXXXEfrZ++y5VFdCWeCgoxee0jQGmzD3tmHs6xgW3a8Hv8cdQg5a5crSmoNUwyUh0V6dRzpggfLaQrCAotJ1ue8cKuguZAQI4Ma15oiNfCLz/aLJ+N8bax+jl95o7lGrb8fg1W64xt38hpKohH6tSm9NmBK8ZXT8EgiHQ/4bfbwbxh04jKgi43MMBJhhgQYs8GizGCKT7Pc2pfx1vjkucWMthCFue01gpU2QJvSckFUnMfAW2zCtECgUymSHhIPg5X5XnYLTKnZdvUGQbIQUEyK6E3ZkipGm0hWr2Iuw5l15HRnp5O3wb7x4eP4/Apau84nFusAtga+7w+R2l1u4RhlvRaoVnzFgphYMAwDnh6Ho1We+os3Y9bs22vG8bMLRm5em2uHSYXwtQ22Qw7W1F22SQlEB56SB8P83kevWx+gyomo2QQfN35krBiPKzFsPgOk/muo3rRz7b/l62rs7TF1mnShspoY6kA3Glwe9dJeQsq8UNz9P4Hhb5pztsNIZkinVU1mKgRV3vnql46x4Xj4i7P67xujzaJ+JCuFL4Yfq/7ISBbnpEUT28nJkRPNDGzEQYZdm4pjUdS1Io5O8BsGwbCmliNNa+EFbmttUn4jqCUcuyD8dqHbEO9X2trX25diLYdQSsPEEgGCgSEEwxAVIkt+wM+3RGjmhJIOYCZPejJdnI9ARitiMWSS4LlkIxD7Y1aaQr+lHVzWZShKAY+PjqJkswOBm8IPSIryLyyrZQhnCUEEa/W97RnVHLOgfKjdxfupfqApEaKKQrzi3NtVSCVqVmnLDRRZRkI79E9KZc/RktIZdQ0o6yXDpA1CxS6xGfkC1bXeVbc7ssbYQBwbY2Ki4ILpFQYQQEzSbAgzkcV+5gtjbn/go+7rtcFeR8Ikka3qp6zsw1xevcEeIjCI9gW5m9hQ+4281vHTpBrff7T8Pd/zzIoaMhotV4BlB2OkZlqjAWzoStjMDbmmzu+VmtVVVVVYJcoGAzZzU9Ow/isjGinD3H3XsehwHN69OAwAWAGAIECdaVfMzjmF7KCYfBUi8r5Crbkr6u++2/o7Tj6PAjf30buhk17iK5eM+jkD4EXUpQkiKd7daNBPktVAr6XvlKczZbuKs5wFkKwbQJ6V2tcjYI2CKotWTsePXr6b1jrWJWU4QkZpxDUgbxPIjFRCgli3a2t/UJtra2pWk4W+ar3/uoBoRiRlqOKubZJ/Aj2qFjD39PI2uQq2ucE22OlATuJc1EudzVsvzoeVtKMaml2TmOZJbRNC7sNTKQUyJ82iilyCUu0dZ9f+819zrfr/rZNP826xXcdqEMcPJRuLqPvSXJkAu4zqF1Glutfr6/IE0ep0ES4yJRSokRSPqLIdkOyGhFhfo8/E8YmiqqU1qAc8Ru8LjWUAXDtmTd0aTGABr8XBO/oQeC0AZROhD3h8wdtXn88c9Y4abEvXIykU4cKUDZo0nIcoGzs5WpTaSd0sOD6TOvQQwTmOc5zHwUZVqOGDSb46HpJP8w7gs+jhTbh1t1z6T7O6TzeZ6GPdi3EvozlbSEQ2io2jzFa1ULAn3Bt3GRu0DvQXOR1gS+YE7USeYEekFqgsXXIrQn3iOxFaFS8gW57CilX2PYc6TZU/gxg/fBDzg64Q7oKkFM/oGlRTkZ+x8qtq79dU92go9922JpAjMV7JGvOBCAc8AKXURAWYTqG3g5oXuVpzoUzVlmowz611VmFLDqE+ns7YWtGP59HUqSKrf1pGxt1cAKgppUS9SHUJpsmc0ETfhvEfzv2pd5iVKNMsdG4jx5q7xcr/r8TcglWqJawCzuadm9gzgs4jKJAhiQrhk+e8PpcTLyAyA1wWAc/U83Y2LWRTuoxZFhWchtBrueadLnabXZBxNHM6QubkzmiwUEDIOTxKBkLOCQQMg5LovlcRMTw8Ho6FhnJ8BfYKY70JXoVdsUZJAjMiBlQZ1GgiLUDqskfWyBYV1QLiVktYlOBSZAnC6DQDZI6O8o0dnWKQ7OpbvqsKr0YWIyo3UYwR1BaAoq23vodNxdTChFt1H06mAXVQNhZRj9GzJPNB1VVV3yBY275oB183/64KdbrComAsgYL8ROeQiznAj478wQd43d/X+//nbiPKB0CeSWsWXDrTRbbIOexkBk68Po0ToMFUmqtKMGiTE5ecAVw1/O+9U8LbmYGOGgESgKynTiiGOjLRt0PZ2wtuQDKRl/bULJ3fPpY8XS7fc5vfvHEpvOapMb/l2K1Yi8RjL6sTeq5oWfC9kaG8gkbGaXQvZfA5upn9tpRuosiyPg8rRfzYcnpTksNbYg2uCzQ7NanIh0WZM+O75oN+576IobzIEswZwMIaDzOIhPT+ZoOJ4Gx/o+B3H393sTieG8PP2ihDA0UK1gwFTaAbJuFr6Xh5X2dz4vp955db+v+m1ee19yoGhyAvrugwrqMW1TlDeSSfVvZTYcLGnnDBjAXWc+FJN8ri4nv9D0vA7TyHxrQuzcu6N8hvNOBK9p815va80XL/60c2cyFFoApCXZ/C86xhUbmsYlp/UZt4u499k7MNR8Vog0Noe+DK4M80YzB+nU21q+RxEdrrbQGpwIVdWGNVl9GRIUXgwgDYBoYUZBOniwtLY5uuq55ss/ZWt++y+vXa0xMdLpciEupbzHdzNav18C32+Xf8PV79D6PqerU9jmtZayw7fSm6+aqwGz/o80A4urvOP52fV1emNsYMBtDYt73lfpy9CRcjf8njenyaD0VFkAYBjwhwtWbI2MJtipQ1UTjRr4SabG5R2SEFykjJHPOIGQPHoIGQ5Rcp9piJmctTQ8i90+RyJWCZAToODASpieXT84WR0xFNWErLvd/EtcN3Gu8Tr8jBxsLma+O1eQ9NRvKWledHF1cbo4+lkc7J7mVn5fn5nV0uh1ej1ehRdLZpTC3kV0ggBTzDEbIgtmRgM1K2YBChDcgef9fpe7ZusOB3fbrF0Ob283ulWFgKVRdjT1eKywEW2Cb4QWEEwxmADOWJLkiTwodTeIlixYrM4M2xYb4zxnjxoKMBstd3UkzfbaZPFZiDG+ohkSoEOjwb//7+Ex+19r2f+Wz9AL2xrebzgGoxwNgCwpWjNCKW05S0lAIZxmcfj4skrsjSF3DzlC+CnqYcD8KO8Lyw9ewiG/vI4vkgomT3WHmQGZDmczmbCNkIOwodeGgp1bJ68MtwLuVZtSj8vjfTtgSyiZmLLYfotPn7AbVWwvudig0M9+zdjYixydjY2NjL2NiY6Wzs7KPODUeIO3c4iIqzl6LNPYzO9eYIF+7THOe3+z+HuYzTTRzrQdQTW3duS/uu1goq+C+1KyOAjvUbpHj9jLsq7OqYcdspZaSp/1HENvcFky0spZBchzhgMzMWKt350qFaswZoKlRhvTCMMGxC9evXm7Rnvc7cv0OdxSPaI0IQiC6YZ2YFM69d2y5HCPB6nU8RlKp1arkAOYLjLDU5VtVJ0k8n7XKSsrkpze87Tkdc8leSBF6fu3v732psJ09eHtMHK/Xta6e/KF9inxt/AU5PeYKXeKp16nYGb/RyabP6sCHHYcnrB37GOTrSJDcRQRoSMewwEBclJpHTHyVPx6D//3kWq+GNXmkylicAJKh8CUfaTY+HlIBjBPWf5JMMon9TARYqXbdFLvE9Kelt9cFwsrX/U9X7BuyPT1UU4ORoBSYasQPHmHNbJkworQCLUo/oZvAb5FypMYcR/HtlBQizsIeio43Yg2Dk/9SGDwf3TTedUyL9QiKMPh1pnor9c0lja8zTxkRcvkHReNpyJ6Gkag+HroavE4c48+Ka40Ms/rPT5DkN9jyJvYU/JyZpyJpPOzyb7R6/5rvgcD+hn03o1AlyVf0OkKP0d4fS+7J4/jqVUjpW85gVtVYoLgxKmCb2X+FSa+6+4gF7+aBWxbNecDT+4L5CW01gfMjTPUKyD0iBUYN6/7wayKAMKu0kVBFBGDR9IwPm0kIQYE0Aubrghj5U8FBIdkzcYsB0+Hl2/q/2hHSf2iWl8RiPxGwjT91mEbBq6s0KstTPFeAZQsgGj/l0ERPRMRY3zDl7fzfJ83BAMOv5SSJ+N9KYBMP4D/vu/150Y1kSMNowIpGyw9/vK2rSPExTabNxbSU5OpwXx1fygk8hh/bYVWBXu84uPDp9TiJqPQ47lXcYmsiuXM1S9proQNGQIxQxIlnQkmZEVCiV7ihA8REIqFEoVgjaO2Vy0xrFcuxgNuKx2UNOrZ2HhAyglHaxvr+0Kl8UsEGz6+hSw7wobAodGLBTj5iXD900EX6jwIMfiJL4qhsIktL4A/OnChS61qOyIpDU4H0mIfqfnyZMlzD+5b7fxuv8S8B8ctUA8SEc30v0+zie3C+1hnEeLDieC/Rpkx6XumCCBFXmBeeYcowhvqWqUCXie+ohX1S2YL3SAQj6xSabXvoDawtTwDB+VVz4kvXA3ghhSd8Dd/JoQ9tSXLsmYRMwhDG8TO9KtTVl74KLqx89I4GCycxEZL94qOYm5q/nEqJm1GHZQvctua7EFq9uix7Szwcrr3WPgdhx2u125rjdnY3vV0eBRg0tWqgaXNR8j8HXpwklrod8rVZOhYmMSdYc4NbkoCBzgp44ApzFKUZ6OrtHXs/EtQY4mFlgY4CTGyhDmvb8gDlBvyxFkCgHaIDACftrMWFqBaooWyWfFXz65MNAGi0xgreQ1mK9TEv2xdRe2l8vy6+v0meSpNnk8nk8mvxrF5N+7fqKsNMzFfdQcGldR693rNUYTBhImEOYU9PT0+hEQynQiUogDQNhgiDQ54tBo0BHImS25fn19ap5NSchmpqPNSSnFrNeLn7V1LsbyDUGaEWnyPr0PquvegQNT32VMb1t2I+OlmHzc6quePJUFYFi8MIy5PDJ0fhs/3aHr3KDMzM3AQgVVIBcfL+dyyCXb9+CxH4wc1qOXrinyDqOQ6jUDJPJXHIj+f+fyuU097FkS9T9R0MpkZCHEfPH5yumkBQBXfrcjjbs6qD2dXm+LIk0aVB69evXr169evXr3HuLCrqhaWeHh4eG9evXr169evXs1NY+Pj3L17Y/WoawCO5/3LQqQwvDCpMMkwrjBuYOTB0agp6s1FWQRqKLikeSwMB65G0qJ8fLVq3AeF5Z84GSbOuZCqmuXcLmAGh/UR5yl+cx/lmMVKNll2Ozls7jwez42x4UFmlVIDcT4Dsnb5h+/kQHjmABya0JhFJ++dPaQTEYBd50IqDBuBfZJsguxhdOMT8GKYsQpEiiDOmR5oEnPEuQPZVeunMHxPCyeYn2eN3NikTyRKZHKyZKWjrO/L936abUF3mIGNcCTRk9y5G5G4Rt4uUmyiaxvt7mrs/Sc/gqkzgh0/F3OX3x0u25eu3q460WlNi8uHLhoi3OrL/ZCM/3cDsnuS98/GLHPeFj6revqcHBwcGEazEPb19ho7vvsOzAsyKBJIcAyLn3Lkz1mMpK7Beot6dg+C+hpDjRvPN3ZyGQwTTRBwXulVgJU1ItqLb3zcZOt4+asiPxgIAIgJYig2cpLWM36yvMQPE/XxtfWbdUhBmZjHAP4se4l2ra1sjWWtg2WFQpuAXWG860SYWzkxykL5V/4rcX7BAi3Tg7g4fDIAehds0HJJSuPyiARMEoU7TAjoBfI4wg279dAZoBoCDMICgnTVV5mX4v14I1pJjP9xOw/NyTDvWc1rxWj9T9WB4OzuL1rfacHdfO3sRtuxIG8G99Bkyf4ODl2C0guXXru+dE7Rdk7RnMw6SLC/dlfyqDsr//JB2WBgIEWBCubnj3BbwDrdPd9TkgAdaPWteblMJdrbzK2jMynAJM4ogtBd9FKe4NR08tKtWRgwYPUSLNY/MteazgCdHHndvptRWVZHMk9NqnXqBJN+9QwdhCAxwpRwonjhPh4eHh6XShxjilGmGZyAjNQ7rP0VZwDWFp4qdO/y5TEEDLTGvhY3zAGs7C+Avv7/jULwssjrgS9EiAU2ce2COt5vvvyUCqvcgXwXwYo9gMoAMAdazIyxEIxER+QfWMZ2/25mCggPzEMqO1je38Nb+L/17K4DnsQYdFb8Kg6YGBJEpKUk5GHx8X/jRAWgwVEtyocccGCBgxUlh1ijhJgwcwDtX5zznQOx7WZlb03bpAdEOwpyui9tWOLvsFg8eL7rJgFzqPrE+KaDNch4RBBBBCw0IFCNOoNAnI9CmRRNi6ieFRBzRBmRiJARdourqm/xes3XsI8vILqruj5xxMJFItH9xYPAdfqSyfKJXv8DAwMBI06Rk4MxAjVb4sqKq61tyAWlP0fY/nJpkwvGByZAB8kUHX7k9rXsM+NLvM9NjY7QrOlZvvqs688+k4kLX9IMp5cGaaJgytGB3FGdEOL6phhOVIFQ8IO+DgAEcYKVcXiIEsIybou7dejlfw5YBJUW8bQy+sSFJm11kDI/PrTtgjKTJEgGIHugB8ZyUg+wMJvKyo31vqWtrWzMw+ioKEfzkYb6l4NuINmoKSe+08g+12kvz7SH5m/OxBd8t3jIAReVyuBKUp5UJYkoF6KA4LVhNHAjgx7PDz8XH9oxgfOsxBHzzc7v38/P8c3oRCBQBjAcYN8Ss7TX4V5QAg7K/+kF94Ijdbge5mR8uuGPz6fr/U5ybiQHCZLOFfmwIZefBMvRsCOoMZSZBmAzZVz9F2cPV1UnCqs2Zsglkjd628oJ/HD8I6lmq+g3MXhu7y3hLlxYiv1pjjzFHMCXnedO9DoTHQLrEAMO1c72quq2pUdbrafWHh61uAM/PE/ig2fywKnQ6LhOKFteY+7t02CBSGo6KDCYi5Bjjp4/NghtguQSQQsrJAJEuNMOgjVPicQdDVtYeJT4V9C2CsjlBw3weRAPDv4T8vHDpAwGCp224gjwQJQ5oMIgIkqg+zBKt2fXCrCuTeLVCBOdUuvlSFmjtqlQBzArLhnB3ss5fIwEuXgwx2jejXxWS+cTf1ODvK9qXcWsdGxY57fimnzPg6hmEpSmDqHkAbCnFoq5vaoi+hcH0Ly5NBOLwyShCQpxYAAZpNHODwuNw5ScLIwR4AXdjaF5n7CBYl0O/6ff9SdKumlTC8dSoXdrR0bNmy9rozYWjLdsINWmCg1GNhihhJcu3ryTCBbGwBsWfsRrogzMzBvJAy8TjL1L5cs2rxX8Qg970IVi6jELejkM1RnKYlqahDagCoAwCKYGNMCoHjUPMpAEOhcIAOUsoCAQZgWVxOfvnUx6353O9hratKlAJ4b5BF4PsNba8ZCNWQhEnmZ/XvhseMYf+MYgeEcHwu6e7j1biYwRPzLb23r1KUpUGzErxiioomFAy8S2qBaAl5puytVDlFQQQi9z+JS9iq8cgPTDq6E3DAerXuX2QPzwPBA9iSxFKMmoGPNoDjG4eaIeTlZP9suCA6noJFAyKWRbe3tkG23tgbf4na1XQ27uc5AdI+DARtGy4fcs8kB8zjbpBAj7ppPhg7OSQo49Wgz5bNPNAt5UANA0CnX2E7eua3OIEt1WrUs58oAFDDUD2UdvBaOmHD2BUpvA8cgr8TnN7Hd5tngYr+POP38Psezpt5en3KagcFsi7zsHfBfkAzGLX2X1h91rJwzwxA4QTHT4mokTAOTK2lI43xeevpbZAK8Aby0kHaULWtIXO8Y2z29vbSQaAT2sprhcX7ztzuauypzdwn/S74EBVXE6yEkmNrXhd77Vc1thCBlrwvXr21tNBjcPlQyZULOhfX2tqKqqcDV1dXV2cV4G01q6urq6tc4xnFZiONXW4XC3s73h2O9IvZydlLCqrTmMTgAY2o3ML/GxwKy7/srsF68rUjknS4qXYcBdhBb7fBeB7FAqa1OBuuZLq2oQ5fa3gOI6XMgMOWE2e1nCvt17euzteGC9EGDBgsA2V2QeybfmHOnm7Pmvc9ZqUp2qjCEfISwRwQGHpU2VsZG+UxoQBfrIV+TlW6Y13J0d1IMYc7+jLpImN61Q1/KmMANGVDwyozw2OaTNkGTHQJBDGTJkUU6nIX3bskEJxju5Tt959YW2gOKEiUAYXNIOC0dPnyoyvULW8COvhjA8Q2An3bviX8IBzxKCGG9m2jFq1U5EIp0OBPZ/ZjaaNXYpcZWZgAwjUiSLAyUXEPw+L9eHGB/U/FfzrY51RrewRz5obvS8HW/nSRlo6LqeAoXD9zja5eoBcysWuFXxo7IyqaA3G2u7ydbd22nAFw/Y8rYl1Z0EPSaVbVjS0o2jysvLtLDLxNSP40rWZcS/N2VvJ2kdOQKSi4TWKiOkDHODECYSx4uv5PK4c6koHm6+Q0qc2ddZcwuP0IHQ5EFQNsKoVa1Te6O+xVqOxBD3JItUYOP1cYhygXJvr5XGjql7p/z/eqdZRaQgwZBscE4Bvnf3ev7vcvVlDKpFA+H6gedeSazGgUrFK8mD7HTox4lMqZKTvpzAOui9TV1dXITNw6u4OVsLAbM5OTljy+/wZqytrGvr7WQojGAotdMuYSEEDF2LOPj3FlVUV8lZdSpyYfkvFSXAdr2LDikHID01wF2b3CRvRdLQ1d694Hndwb7+WvXQ7CcEYSMPdR5HurjIH6UFOHUP8PHxlyGYYQagFQ2MHPjkSyHVyIDY8De5Ngl+zVm953nAfIuR5r/bkJEDKzc2/7rIZd5+bjKqx5cXy/Q8pXocny0lAAyAiBQS3qAcBPENRy/5nb4ivY9FszUcY/GbHDQ5oAVsmTQu26nQb6mYBoQZNf8okx8DM3JENw2AbZBSBPdw9Lq8zP7nj4L2QzQbWHw/mz+jsVtkpSkIcqVGuCRkUrLgBpVghK+1Uqw+pQiGYnQSI6BOU3AcSxh9MADW4Yt49BPRvJIApWEZ2r1ut2MTWhF0AZAfJmgnK5bJbjmVONxqlunbiNqDQ08/L5e8v4/MkxaZ87ucjbAKv6thGMwCyEm8k6mRSwG5hSudb/aShtPJyRRq/iv/pb0NQNZPcr5tmA4uEEISFjCYAYY75LpUYiAIjM+mGbUECJqpYscPV6DvyKcO3o4XTPJVfWIbpjUalep66LiB5f7+mla0VrXwfda3zGta1jHMWta2J9/3GWk32cb1r5BsSKOCPd+AgO8x6L32uMPMyMDJDMAEuZGQe8vP66DM6PQ35dfpt3Di4lLsIQog4Blp9waNoI52x5lHAsALqBxwkDRrguGwDq44B0Ll3V6eVIU2SN5A4EwaiNnZnifskJgKDC0bLtttfNcVvA8CHtgG+WMzMT0IM0mlEBQ0BBhO9dG0oIE1AQiO0BU3KFmuZs1zb89r5IC1ECmA20tldQ2CnBlVVMcuEkpBbWBB8IOb1Pg8nu/ENJpxz4MerXKwHgeBz+XLooWlTqK6BQaCvMK8DtQvAs2An0cfO7va1sQSO9BgkfZhA9yAwGECBAGB1AiHfBnhMAqNvX6VMKYUwYQDeAwgDCIZwYfUhpCwYAsAgXCBAYWCwUFBYIGAUFwoGFBAoIDCgoGBAMAuFAw0AK4XDgh2+zgHP7O2awbsJghhbu9+aswGZkg9Ghv+7p0EN7U0q63w0fFZZwGO6OoHYz508xEJYBb0XULW9pbybkgBGjnwwuHuJVJUgNNFLBkkMPD4+OhBJRJ8DyPn/HlWjPUpBBjkRDRsbbQ7bQ1l8HEYG4C5QFSswrCz5ZDmcWEU5gQDwZ5DaYCNnvOyRb3WdTyqmxDH2SNtWszNtpt9pNlb3P7jzJo3cV+76+j2AGxqb+Or8i1dwFlVKNyciksNv2GDYhNpsQueAVVigMPW9xgfI+F8j1r3pdh0r/NSV31dbc2xCloKmiqD/uErtut7TNbjAHZBgjzg8rpUCOKEgQAygPN83xOtb+QeoUwjcsZEFAixQ4fCl6BJAGhAWy5d0h1Y5F9/+7KBI4WrWWMrwOriPZm8xoja/FSqocFsgwM/xPAxrvdbogka0ynqYGIXcLpsUDOq+l959ZO0sjg7YqRDf9fcdXq5vGs0tvVthJAaQ4Z9yvPhTiJ1EbXJD3/T83G07ytSD6AcfU5gVuPwwnsjY2pGwaMiITVDsXFsmjicsM6rnCzpvZonzg7apINsY28F4YO0bDp9xttr5+3hUvmGjTopc7i1e14IWNS1CrXBUAq4JgBAGAwYJgwuDAKAYCgMKBgKgYMGDBgwYCgDBDBgePTnDpWIKh0mm2Ihu6K4/bVEy7pq07HY7HK7G94m34nwtTT0hLnM6dtcOAYONwWd3aun0aXF2WhRoaFUqtYDINMY2EomMYttGQYVmtV1Q4OBdCq+4z/u8TOCz3FXLjl4MBfNDV6/kYcgUuJRT7ENoG0AW2AlAgAwIhnhKEofLDnhTnpZN3IscPMIgT5ABkQf3eLLu6su3wUG4FaN2OxfaPt3nM43mMQwY3jAUuXL1+XwYHLW82v4AFLzn56vpxCUMjMwQWqJJEWMkGZcVbGGvtlMC/76mXRJuRbTwT2ve3lihttt20zahoM3Mvzt/Jly8GbAYcwevj6sNJ3pq95578cCi9dAObmLDdxzRPqGogoO0PrRjGMYzAxbY2xg+6gSExjFQURypBgm6dNBQ6hBEY2EajjRPDiI1Q2DbbjJUpttjYDY2kMdnao23UjY22222MY22mMbGxsbbGxsbbG23TbbbbdSUnUiQNNtFgDntNtNIR32/UkkkkkkkkkkkkkxqrSWkkkkkktVSSSSRupJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJCkpUaS1NTU4D2PaZgUgluJr7TT4evl6+vbnYBeiYAwHpLSCWMma7mWz+D/ZqNurnihuA4IBoYOLE5HM4lCSzftWphwBn7jYYIQK/+PW3gbngVqxnMNTTLcbUY3t7APmuoUyjSwu2rEJPfBWhOSMXAJEfl8azYwryjkgG1BxoPGmW79BbjcbW4zYBssjE9s9HAt3DOGvEqCROaFQgJMgUdN2ADwAMAMdEDR6PHPDDdXlQqAGYHjh51rTLahODbTbbFUzeJKrPbZEW2FEMmBpXxomAjR8bS12lT/Rqd0GBqKf4d7/7k2dyk2022Xg5gNBoO7e63E324UYVL5UUWJ5N1CqVDlBHZE2h8SnLIoCsbTemKmJZjXbulwqpd3tRzqWt7BvPXFgFzTcniYc42imOws1agoJkB61wbv6yL34ElPiwui1gb61Wmq1YCGLKs6nkzLEbQ1PzIUPRuBwMUNK/RJo6OaaMnr5walmvYaxRkSLg2rzabX6/nfCjfYFPDaLdVGjW29iu+Rm0igUjPDYCiDZr6Sx9jibXiy3G0xjEPNm05/T9d9V+z+N1vU9/6GOk0rr6xtjLIsxQih130M429LPlpOk1w4EECpiaNCK9H4V/EaYxgp9DR2po4oaZZ0NsUs4PdVtJGlNw9PU3Fy+dJwbhCCbZfvr4AStYFVr/zGck0so5pxOki8pfapUQd+06kqEzWMHDSAROgWvJtsM02wY2lts3gV9rl72lsQKyNnahZE2gbJ49Pp8rp+JnbPZqtRnVaqvIIRXTa81Le8eW4yfACAmMVAkBnyEXrenfAeE8r3/xLf+I2Emg/Ehm0xwCFWUEPg+BmDMrVm3u85KsY/GrwwwiFOAZ1bEmsRhnbGiIiRogxstNCOFwsThTZLYmmmgbU0fcY3s8Ppay3xvL4/l1a1sLm1cJBCbkZF08XtzqW7jqzIGJI+87+lzPxob3fNEBoabAJnR1+uXtTYsX76/E+APnQ9F8CkA0svFjOOhBAzmmxYTEIKmQWMAh3DDqvxunFntO0fxtWLO+40TUk7ji4UrNIM9aNcRBe8vgdssDi9yr9+/fv2okGI6pkQYAWfKAsJgAlH6iSt57YXU1bjIBIEVVAQYg/FVqNiDwwklmZFak2bL6ipZsWB+naW7Q9tCtAXnd/c1gMItiO1Yte0sfqanryIolhiP07UCpn4+e5IeHm5EvYgBmJoChswQcGCBb7bwq3Iu43r51ecXr16peqvHoF2CkEQuBsAxg2DQj0WkEDdgj6Xkm6wygHwQA6IdyCXkBvA8oLYRrAwKZs6gGur9xqeVw+eYId0eJvbrPwA/LPRPBQfmppP0x/JD5QiofNqBjxFSpwgg+Mv+gi+kRBFsUagPMIpaVj+5M3y88mgljUS1ifgCDJUlgGcXvMgAHcqFbZor5SUrqbUoEODfGHgv36m1wcaenjcYcD6yAZMkCIiBq079BJAJEanICv6hweD6a9FVw4VzEZpF4LVg+EWT7NqoJlD0psChO3t7ey7NFsQC4FH4LrM7TjF4hr87LttoBYQsMBFu1sgJEmSn9o1PqrdsXJvBEErw8t92z7HSdCOAtqBAuMFmMEzBcnA5IArGMNNQ5BXVyMGDNzyMiZu3j4FvD1Htk3bioAaGDF3RK9XzkQW4o3w4+YAA18buoHjQjPz9EvQ5A7CbYIkgTzIFrfkayHQZDjoG9GK3oRFRt9zGsBfRc5vn57jIKgSwgiaFFzqgg9BFAZAt3oGYBeBhCN+F0LsxGDyDBYtnzgC6wCcftnkhJnwLtGpwwQyDJWxljGODyWP8WrIYgHSddCDNCEBzBtautqYuK9ZfG2KjgHYmtLkZggYe4OKZlmRKZKylbqpbAMwSjIlcEZ9AjuAule5VGZsREl0BTz8KCkofKJjWoM75wji2BsMdEDbGX6QYB1QqBpEWF6oRq8/r8DACqY+2LW8JQ1LrtSzYDt9K74ive5C4LlGQlehlB7kGjqB7CMhhr1rIqnbUoSB3YXqWMXaFPcmwKVxTiJq6xqBjFBi1QJa+Vuco1gjkxN11K2rs4cf/9+R8Te6oXtk2cIG523YX0uXfRQsdo03nGMEiFU1qFloVfivUKbRZDdUkL0sPc4JcpU7QcHKALVLJUo7qelrZ+J7/p+8pgVJ4Kdg2ns9nqwVQ3tjPJErQyBXFk5edvivP73O0L1hGX7ZFPAZbWWQZpfAYWgmoWUKIuFCBDfxpgF3ErvqrjIeXBO8v3JRBD1oAIIWTS9rpTWz7r3GExYyj4vRIrI/IXrYSGN0V8zmM7UxrWs26S1lZL01Nra2vZfU/oed1BvfAitcAQkVpYQhKUpe+ilKUfLWQoFgr1FJCzP1l5KeohEjL5thtQy/mrp1EI62dK71/KZtjeEePfSjuchi+BzU58Rrc5nRJ1b/q8zd9Fp/xIf5IWlKYRei05hFcSaVN5SZ35/Pklgakadtzxwup1fkv82FaUr2DUnhNRdLQTq0FMGMcwfM7ZuK16/TZ53sfO+ie3EjFufzouRnlCKBFnsNbh3d4RZv0pktytOZnwIoN6mMuo2QBjgGMb26s4QCxdMp1ZiMlN2LfBxdnm1Teoq6nABjxturCGz0QBsBCpsBBAYIBsGwB2VXsiOrzN2kxFqQ8TxJa/e+J2x3weGg3QZoip2tzxo7uwAwYhny7YWfj1g88R6u/0xE5TAweaVUlBFL8fk/H0PT0vUf9mD+tFsV7GApHwAQD/yUAYiEB0F0yoI00YgaNMbU1OnGPSevXv/kBqB0PH9RDYegT9m+nfUGgk5aiQPBnA3xGfay2hQthcE6KBy+07L7rOrpq8gJe/2VZUIDgeAyFfH+v+P2bB2e9EeCI8taLXD0O7+L6XpelSpCGI43i6Hr8ia8DBaLgNB4UFHewMJtkDMvzrIakWTJjpX/9kypgGAeV6qWWbNm1MuUBhuZm/QgyhjFh7b1kgctTuBDluA7MikGtnszVk1oj4Ilk0+xEepTzLuvYJVq0t4AccqhvO0+ZWEZIg4pcOtv47+7Lodxg7JTS8OKkAqMX/aOMmowxqM0D81m7kJhMaD4+OI1mNVsCMMJcIIhq0oU+j7W4sawRd8zc/PCwKzmV/rfZ+n9jzqXmzi8Hm9xjkszKCGAWtI+IB3iEa8L/72iVPcPMBNbt2cjJb5nlvQliACXzDvVrLqyLTpYHYBgcxUoJh5XTDnQuEsHOEUkFMLPSY0uxYU0EIoaJqKVnhQ4NABUDiDKBoGCSgRcCYokQSn/z7OtmZva8hecEKYpbG6eD6n6Ot/Vy/sVPjM6kpROqpqUoNKVLa1i1Ja1jVwZKE4LUtjGMjVOqqU6qpzjFjWNXBzYOdCEYxnOqpUmVRhKjFwi9z3PlSNVVKo1CNU5Ti1TFTnObYg2xBviIRShDGg2NBsaGtSaF1VKZVVCLosbGJsUli20lGEaTqqeKBokKqjqqNKGta1rGNapq2ra19VVVVVKp0qnSTZPzs6syrT0vQ4e575g8Z3X6/Y3AJk0EZluQRDPsLYCNip7EpaiJdPp9Ofk0/S1+GxIzlMVcQCcUpAL/k8LdhoBsw0ezreGJVQrFeTAWC9rb1rT48q76UehkyelDd91TSs8fYA2deNIx9PZ54+p9B5LVvgJqm+NBrwUh7+XACoMzOB79BBJrLBy9VQDnyc1syQwvU4aT/NatuyNJ2UCMM6YSlAjDSNMkULRUxPNAlQI20mwcgRzMEVNOqVKoDifMgRpjTzwIwbTGmwbBsGwbBsHIEYNg2DYNg2DYNg2DYNg2DYNg2DaGwbBsGwbBsGwbCzM7wZYTMw0jCg5/dPo6GT7t5GUq7qvugO6hFmBY7g/d9fXHSIYqW18C6ia2uI1fKv7IO/3zyuiHKf0c22s0n3FfFSt3DIhuJNiFyrCHmG0I57Ksi9zB3eEwEgwwha11dtoGxjbBMGDQwGNItjRg1ZDbwrAiBuITjSkeIJQwxd5aXpIvVQYylVUAU2mMSboZSAYXKAiZGRlrVTFHVVBqgTVFwE2KohtjTTAm+33XA8LgdjboQSS4hFo1y2ScIMTVQta2Fwbbr1sf6nuKvkb3oBTJsxqzVRqrOHwakWeJnAz55dHPWRnGf8LbOAw6dlJTJQkKGJWbR0Om8HBXKEcC5GQBhKEYKIbw+sXwbJLloubf4AMLaAbt5jZuBgUGdmH6oGJtRGLBiZMiWNHC4uYMOFQKM5a4EEIwksJEQwRHEC7Qr0wieGBigyAiZFfRlDdyIF/8qn4Lki84xLXbPO3jUUDbMXEnPgn85lxJcU2Oo7WUVFqE/AGDLlAy5ZauXUa5gpm/xcZgHTo0oQzQhDynoSoFBdwIwVPKNMWHIfs1bjOKEgQ+mE6iKWBtJU6fEeZ/+NjLlMJPOCprqoWAYILACHWYAellie17WaKo/gDMpJzZMubz7JBbLPYS2cXhIBFEBhGAXpgaLvQHxMBNkHO+33sMklgMa0YUbGiAWQUGWho9DrDll53dHh4XFoV4LyeVLWf8v2T/iUhmCVH53e878/xu/1S35fiXxxjY3B7eW0i4Vp4fcwml800nQDpKmvnfJduw7P8zsCYjla/NxP9f4JV3/v8vrow36f0zLGi/89FRGT52X8v6fReNPk/jpwa7bC7Rff1yG1a2OEwrZd7AuOJy/1uubd4Bu3566sPoctO45hkKaxdx02GOkwzkv4p6Bl4A8/dxkOi93c9g7qUUzd47KLs3ig88SQbYIFy7DuDtCq9JgvZHHwSsKyRx0cWXYfCnThAnM3wYM0WmbL/o7XZC2fjJheDRpSQ8z9yb8PkftNIm6WZp89ZCr+mjOO89FrF0bk7lPK8nswBRw7IE/93D7jdpKSSF44+RkZNKEGUnFaiJ6GAumoELxrO4xfgqIlqaCW5ZEtawS78GtINa0glzcLVYm2QQmbIIeQXRLloUZLIW/UYoLc3YoA8E9y9s95vU4BwKj33u324WDiDiLkgJApy7n0XhxBoFjVe8g/fOd/gINYQzm33WrVUXEG2Ut001qQdCQYrw2CFgdWRCzPoOpkx0gLmoRb6hCivpLBdxlolqBUXcZcbcOwb3gnN1hrbT0nFm7IhVm/nfSvax3iGLZhAg97srK+NOkwLgE5zmQZOf8KmevEPEOQEYxIZmfOf+UTtdGVqYE7EilX+mOdrQBZX24gW9u/7Ye+zZESFmUo6H4uJ9uWyG/nMTADTxqBFBSl21YZSUhi/prBSkM8TwzlKUhAENeIjB4GGqMXgg51hzcmXU3fSgRXTunGOpp7r8kEOFqjj8ccfXtWrWzsEVixbqpIpDl685zuUoRUpOcikKtec5xBSllhPF1NljFlWbMHEVcYgRdC7thBe8qHifyKUAE5gWZzmJxEYQAEIAQhCAgICDwT3gThB4e8PeGmQqPJPMAOUgJfP4krDREwTnAOdnOmO/c8wUgIQAhCENy55kTnAOc2A8bx3WTsnQCMQJX573pM134Hh6XOILoKfgMJsw9D1cDpDq8sdNYJ7cwq96pd07o5yLt55B7srg9At28RcQd/ac5xObnOJzbRdQPeT4wEoAQa0m6TrJveg7G+iI+3sqFzvjv8BxO/vuzp5uS0m3pFsbBXtOAqPlRjHxtGGKXRfhPCDkcoFCFiqBY1gsbhDjSpiUoBSk5lOchDvIQAhVCBQgVURGMYjzfJpzZzKcynMWbZ1Hh1bGZYKx2qUKhUF+EIQEMuEBCAFji97KUpFLsykJCQEpUjAeL18brwgUIXCvHeMSiBH2XAO5TRU0BrWgNa1p7JwDsbVeA97nl4zyWAvWYwhusxYC9ZZDF02LJY8ZhBnPQAji3pXjWBs+Czg2CMHeB6zKsrRhsSB0RHy4Bpep7bNjmZh2z05gB+Nblz/pUc7ioYMmVDoYWN+Yx7EUmY1WjyHKBmNMP1lKdeV/Jqxnv8cSzliyRrBqLphOHlmxZHiSZUR4SfTov/D+XntaKtZLVR+sok+0gIrykknmbrBAYNryrmL8F2Xj4vYbHm15Du1k4krmRE2jiYUHdoLt3xUhRhRoMIPEaFY6FDmGhiHPUIM23NU1JKxtJn65VmPI6GVqqPJzZ2ecaHYP/nurAUaW+fwLGzs4eRe5e+5axa1UVVUVVUVVUVX9+1i1qxta1rWrC1rc6qqiqrNb0PbePjjjtVVSzqpG4/LqJsu445YmyzO6dPHC2afmbX5/38+Z8b5/q+H/hz6D1NZfKprjgg7STSPCB+r4YjNy1KNVUiJGaPKwKnW2BfgB+/QXukAeP6OlfzSv9+r8kPJms9iSPEqamrKndycH4ur+B4h8wOSHl3Eb5qdM/O1rZGqQjkAh7774qRO+j9rLN8LrgZHyx5lLVscjc40ERCZ9jhKPSBg2moKlHxPvQR3LoNABeqXgL167ewI+78YfzOlMIDgOhURdT5yEMukztkRM6/9z8M7StpMVO/61R0W9I3HHcXJkbvM979Tot61m4lBWMrj9fT+xG/feWW2mGOI9m1Y4haqJZ2cjODcZ9PhbfQ/R/BV24WYNttj7F697fPhweX6alYNGGDsHZNW+/pa+KsQH6Peu72QQD6n8QAxXzebqRW30ppCJmvT0OTyftfj/p41PJ0tref7e+spYLbmtwbbS2jV1GAF20otIIuDBtAotQYDai0KDQvb1O1+zT/3afcUj7r632Yc71sqYgHddoZrcsUd6RzlKxRh7afQjvFbqoYHQRSTJ1ClUrcpk6dtpx/E39Lx66PjDov/6W0JkJAO1LU49OyYJgTM2Dmx6BiTGiMlorRC6FFgs0VUoD9jRxwO5ZU12zdM/ueRG4wAhfd5HWH4f3+UBIKYDJcE4rCc6syikpV5S0JUGKuKPRyMrJZJej8O9DoZsCzc0g/FQumVlW6WwlAfCl/gRFp7K6XILVfltenM/UPbnongOyfYOs9weE+wePk5NrC/Rw3hiNxWchuJW12NOgD0yyAEBj88My4aeSJZS7bU1vCVxcFwXmaW/2ZY3PVkyYUF87R4mng8Ns6dV6nPeqq+d6sVVVXRORnMzGFCCmiOchBFNuKBtShIZSwyZzKrUWGatKhXlcx+uZikhWZVZ1feeb5HZ8mZ+PalUPT6/k++6flfOhfM+JfigNzM2hgUpqAQUMFIUy042aRHUqFTDjJMJkT1gCICHihGRXR8qpLw0LGeIp9vbU8zU1C8n/pP9vAaUTzIX/OeuYjJo68ofMpqaRpSkcqoy5fLjLJrzC+5VWnNteFnFmtd/ml/hPlRthSDKxpjDt26ZwXOwePdcfzMir43h7DZ1RK00hAFdoLDAgwTbaTahCCG13zDBweR1cGrm06O7OM+PHf4JMNDaFiRIDGMZNJEm0KzUGkDTjf2jzKm37fwKKbLNE9v485bpSnIfEpNvdrV2Vr5HGSEgqD6MIXDyxcm5JBoEEssMFOUS5o6bQiIlS5aHTjDkmzhNKuIxcJqliQJmDafw4aaI28sGdVpWM7Medj8ewssbU3xITCKapNfYiX3uzFqKCW1niNPEggLWiCSILOqiSS1DtIkFy+5QZtyISLsBJtB83x/K9K3STOo0kBOCSaHzhtjggK8RJK/ikCQXTCw1YcvECWu8eX/x/q4mGPoUg57XY3NCw7tf5SvOxgl/1BJpHtsO5hAVAeYNABAEj5MK930ulN0uDweB2HL5XDvLAu5r2mRBAa7YQXcNImaEscBMXIavOC9LPpefzDSrnkHST0dODRdAE6mitKN6Hv5p1nPAKFJxQ6dv7XuZYxm8FpBaO2Gnzfw+H5znPGMY/xfgD5PQa71alIh2lY32SQgm+LFYIs3V3V7Lx3Ld8apIwpIR3SAjmvQhJFs40/2COCUSRZABlIvqfP2nm+55DvwXUBvt7GxGdc3E8n8n2auE+Hs7mW2WOX5X+r8kbdaEnd8J/fpNfYZTnaz5PmvXrqYABrB690bGH3wwJV+EfBvnR5PmpwBR83lcGcDcvhTCTBtMRhb7BrGsgkbFH5fzj9XTX7wiJPxjnXyW3HhLL+1+JGCWBhdAXwckqaXEOOl3TIaWlWuuOogKHU1J9fs1n6+oqhxO3ivbc7cGv26IYCscehoV5jGRBn+Z5oDDPSiuIfmbzvWFsGsPy2wGt+A9IJijBxT+MBgNpAx5tYIAxQPvQc1gfTE5WVKeb6UTM9BP6jZs2TZua6gRuMwTZUTCO4plZnBQccJCQaw5QBMgUAJASzudtc12z+mt+WIewUeDLWd3ItA5JonMHIgwoT1lIBBRKP8OQb9LlELjkRFPHbr0LlmRZ2/l3vz+lD/hJOVGjdb4e8WrmnPCvZpiS+EJtDtI53O52H7EQnZ6npQPDE6g2/HNiUVZPBheDmLEeJj8TicXivwtJCBhGOsCIgUyb3P0chrptDZq6y9XpUvHANJ03mKB1afGqAGdRUVBqidxJKdhWCAO28k+mnZEhSTlG/BaFsQt5imjIDPAmRfcq+1RtbVNSqqZBClpjs0LxA4c4mHXvMR4+L7CVceJ4Vf2uNfdEMQNv7sLtTRjPnB0Tv0WMJPMPPxYixdnX8guYHSTMz+mjR0NPpXtPEm8yc0fW0jAYC7bXL1oIBsQkmxIbEhtAvyWgQY7EAiLG02Df3j7/jMYOT9k/ejVgvb/9e0zWthla1kPBopFS0E6uixdolCvlQsaC7xiHgEuEbdSWtYCzByrWbTbbbbbbbbbbbaVOr2rNn9P53V5HadDiY/ydDbc/n9CtY09LWaV3DPGxmzadbNg2JcE5fP/BpJiG+82hJhS1R4L6Olt1aVXIW1tbW1VaWlkoV8NN8Hl8ubl8a75eVne1f5tb1Zdr/FMAAcsMIq6MI+5G22NjhDHW+up1OXfqafJzdANWL2S7f/hWLSweZyYqGxVnWvQSkSSXL2ploiSBKhG6LVwvaks0mwu47um2iOmIolOU2CjUTKcobUAjqQVFSA4yqgJoplUlGinBVCMYqgRlOYVQWksNhTqkoKpTQSv6fo2FTGK0Rdo6VQVprOBWUqlGYSqqo1KoVF5FUIwtVUwcoooKo0OmN02sXV5BuSNmEvaWqR2eDKY3HZ3xl7QXh5eWfX2yeLTUmLkjz1M8uS9R0SELNQkI7uWjtTqqbhQXdO1s8s6/CkbaY7y0qiRlTFt1IN+J6Gr7r8Tz+hWnVpfFMZGkqu1Uf7QnlO258ZT4/sWcXSAchJOnenOPLKcoge+RSKenU+g18+giMYbnAjQ9hweOB29Tqt6nKkwyykrZMGnKSSMjXP9VBq4iI35vO0OtVjfmVho5cvr9XSdIc9MIESVTMgTkpNqqfz/nF4VePlWL05ERESqpWqHM0ZGD0/YyZmThwsqVOAN/PqTCjHGsOeLo1Jyp9Y4092dWaw1h1Bx5pjrTSmQPpQoVImQMiZgypwxkYsmhNiZkyZlTLGkNGfgM+aY6I0Zoz4RzZ1RsDJnXHWH0jizoz7xopWbyfhxmTiZyS77ES4GJ70tx/3E1lbyVx1LPAc6d7ejtMb72D3usPUKHsOzemcBRfMQxNfKR5bPGg4OP7/vxopbLMIpqSjRTUKiHkrnOegf7lwb+z7Tb79/v+ufoHAUOxYjO5OPKilyGjT1pk0zMzOOsyJo3JyTcn4AwYkzAOciIpyOmvBOGp07YynR0XkqrqtlpxE971vbOy/RtWrVtvbs27b+pSKlSpUqNEqNGgF+1MH8An+APZ7E6n7qyBVRxoqA4cCJ6npae0qu5S9zF4K7GqAMymrWlTL1XCntXSzplkQvMzu1tZYlYib8u38bJk+ZxsuUsuUuM0zB2gZ3aTMzM+/7R/dLQbi9/CMuXU1KfwgNRwB+z4//n36KiopOioqKhooQq/m4HLRlojneepRR5etl63sYYzre/p+O0vZbT97vNecHGjRoyjLCsZRnzjOyRnGni3s+HmICQAOCWjTU0lSj7OyoEkSYkol1oFqnLhEimoxsYPKoUMbG20EmQ7BkAXDw8NBQmXDh4eN2b4dm5Gz3tQqkSnTf/lTZ4n1JG+kJbMESIiIoDRm9qPZyzIe3xmSxWJGTQxIhLDfcPE0kMQmBG5V4AKSySi4M0XFxf74uLEXFgUA+fGiNH33bt/du6WKteVH+NGCyt220b+34t9fY/BoJ2gZ3f3gB0no1T1QxWq1YdKkVKlpZivWrBmzsf3snS5mZmdcSOvq/l267MhwK+u9+4pUqU+lSpO13Bcg/El/K2il5+T6DKvst+ZY0y+XxXXaEL4FmzUqFZstgxnKiQCCD90y/b9cxsy2zIoFMg8vLy8vavkNLvlrwFrlklgDOYYAQ2sEISSJ0E89CRvjUrOoIQ3smbAKmksMXg6GI8wvIfDWJCxgYThzYEBN9ubpWwF77PFcGZmdpCIZBGfXCRI4/n5xgNVp1uzm93kQaCMxhw1de1cDazcExwsFFlU31h8Y6ljyBueSLVpZey6zwR7qxYsAWLFixXAr151WtXfIUt2O3UwzIS9/VSFTKSkpISQk5MSiIRQO4cOG9ypYqwMHlwgMOrUtkFrk4Vlc2Tq66NcedYFesys1wK9fYori03UMzMzgbHc3bI7fas7Bm3tFCb9aJWjbPHuV6a3cdxCrT7Nmw/KFM2edWLT6/xfcNyhRdfV9CUVnmPa4Fe5YHrI9dzr2efZH0/mn74DnfkvX0wrhIDFwREqqoUhqDarbW/ak2mSwtbHK6kZn4/l8nk8mwVgrBWC2mWDAuziN3zzPrbSBZZAe4m/xbSnPXvAO/MpFdEIMzNPG0uPjaQ4lTRVHQ2+4SWeSwtQ0FKTvXO9F6dtZ0KFF4muJa4tOz2VCc1/cn5vMaV8lJzUvWkZqZqZIyXG1GEOBoy55iWNLD+ebOFqxX2rG2p3scdO3KTaeWu9+ClKqoSEj9D97rda31rYuWwjcCEGic7HwfU9IQBX29vbs2bNluLIsjw5tG7tIsCUBbtoW2FjMzMzsFdaVtfWO34XdfUt27SAZWid2itqhPyFA9Gvbe12tevra+vrs2ROLcP4Np3wVirVirFWKtWHIcAVP1aqae880cUVgmDSFU6yV+kVEozdA3xLQpUjGlJLJJQDsaur2OxDzV9exr12LI1te0+thXuGYSlmhKi3Y6bOCVzTxONeHCWxfvXrwvAXgI5ZNbYRsB4BhwrbCj9kkzPnmiOBW2fDBYxjZYcXTXxeXgIsQ3xMeec78PJtr+3ZLKtUluKEoB03MnFi8DnZMiMuFxjGXFkCcuVkFFNt3uIUaXGYZ9Uthspv77ZcWZAFnY+R8bRuaR2CatdIfjSNI0jTP/JAkgSAGAPA06UzODOEEefNkjjDjyGIN68hCOqBo352/Ct4cOG+Lk+PavW1WiFr9IXn99Yd6oTVO/wcDOaBPlb+v8fk374uXJFy5GjAdxucXgRwBh8BgwcDNRkgzMzSdkQsA4CM/aRW10Gyu3XgGDb161KnG73oWq1y4Llk2iHty4G6txYZFFC21G22822wg66sapkpaWlpaAAkOfD+h3kff9X3ffwwaZAel8m+MEfseeVkXvc3yb7yvXv/EqS9pips86G95Ke9iX7MJweS7qMLzdG69hSF8JPgURokNbSjFjFGm23SrSE7QLn8+gCIln7fV3Grq6pNp6uqUpJD1nrLWXe6ggPmgazBtESQRIGgBsCMQ2Gy0EYqYRi9+xRghtA2CQeU0jmtIAlYCbEhsENgfTfMjBzDg39cFmBBSo22CQDY3ZjkbG+8feaitTbbbY2NttttttttkvxWhQS62TLzYHH5plo/G8mfmztttulrU9oeTmyZpxdkZpIe2hIq8mx9at4/15qWZb+NeqD58KSj1/F+Z875vz69jDgwhSFdWS8QmllFqXGiKF+M1CB8nmfQABKCWACsth4NUh3ncTJVP8w3DUiBT2O8+3Vr2Ftr31asAb2YjxGk9bsRAVf5cm7+qAV4kLANN6ZaRie9vNOZtt4cIQN9TVivdxVQqVP0/kU/iv3Unle9bfadngal5xAvcXdUaL9d9PKWgzNNlCEWvr5aVj3rehlAAAWZHqxqs3X8H2HIniV6OTxI/4/XeEzYa82De+IjxaMiPjjvbEhh2ARAADixdzc29y1JlSkdBHs+3OiS+5HEdPAAAAABGr1bZ2xPiN51lmyMzMzR5E2YW8vW955Wr5qr0h49uVAXFeVL7uWE9tM1S+7ihoL0v0Hioex5EuL17shO6zj7cgNHYixYsSLEhhMVMVSLUqVH0aNfy0RUOnUl5aqk0wokkmLevYjQ1bS/Yyavt9+gBpihuiERI+PUiLFAgvDeEIP5jChjuTBFPnV6/xulZg16orNL256nqcPhfSeezYCCIPzAQYD80v6RusLK9i7EUzo2iUaVxOzbQWaFQXYIN697og0o40sWiMu7QiqVUGIpuojBiqohSRITkFJBEcdMKqAWG0kk4ypAjIwyYU1TSjUaSjjQo1Gg5DCquCFJSRGEYKNRijIxKSORJSRBSEEiphQIKgUwJIpJGEcaI0o1GKNRhGowkkakiCMIxRpEYowJG4BJCMjBRhGEcaSjCMjCMI0RxgRgowkgTwqoKYRgRgEYRhI4EaRJEL2TSFTFTEEaUYi4AMAOswSUQgYJggGCQl1mAhKCQDASAabABpJCTEAwBBydWAKI8AGL3aaHbq9939ri96NBAcwlNsUcKhTbbb7fqdTlev+XgdXKN589U33PU3dbqpSv7QiIiKzZsh1Uq6ULVariOzgfmwfRxjMeYQmlzNmmMkRkINY0e8l6XTk+THXEkSQkJSlMnjyI0eO/LfiuBFDoRQy8znd+0+ZVkPPUasupBgwYMfrnKfdJD58+b9QAEHa8uehQAzAniC8gz2cH+ldJmai4EIwSkYAxgLCztAwZECQdGzWwcHBiRIkTX5YGzyOQ+FobSwEEPKlSTJkyeKOmPpi+ILaBLsiNviRYZ9OQvIkWA4gSJDWRIkGcU5GHDI5kaNGdfnDxwA4qVa6K4mLARGQhfbXsTlWicgFJKKqhBVV5lkWYNpnKgQaG20MbYxsbbRUBi/JMuAku5+vX0y/ycnJyaWTkN5LydDU7zZW4xocqiH+SUtj8N3HpfKEeNGZDBHjx48eO4jGceOiFHzMJTFRE5Il8oEJDbY2xtjGNpjYwY02kgbfeOAIGNNgNtjAbBtppgNtNoTBNpoaTQNsEDG00hiGDYJjYmANMYDGhgDGmm2NtNANNNsYhtDYmNsbbSbTGMbTYhoTG02NobE2JpJMbG0ANiTabTY2DGDYxjY2m220m0Ng2i8iG0joRQiAAAqCQ1gx2VJczIzNpHGtw9Bce60PWuHf9laxzXc0S48kbWOTKiIdxWt79sATJitdeHK3d7Va7Mbwt738iZGjRIkR9Ch4oGTJG95/UAIyYaOEFLN4hp2MUyokoc1FMaH6uXyXU5t7fi1T6krcThJN2H0apISNlncQYvCb9ysfKCQjIykyYCzTOCDNnBRZ5DlJRvs7ZaPgofXKv2OYuu2JzUeGZvDM1nTfeP2K7M6r2w9U0OITbiufKz+Z+j8Sdsx2cDv4YdsO1oZwDrN5ng4dzmfktkPevIpSW1lbxb9+/gwtfbvClKLumZmbGbHm3s6/BgwXFRsgOHLrgiN4ECBAmPy5zib2ESTM4keM4CijuepDhw4et0HvRdy4zXkEBEdRkkQJQyIFUW31PWe55z+wqRAO5dp8+fW0TZtyP7v4BCbP/Ac9ZSQiMco1lfZZnSpvxBkYp0+e3iw4UOpQYmv6NB4FPA5eFi1X5+T3hOyGxsbENDEwqpCJZofrdcEiBqA2k2GcwUGk2CHjWmVHJIfoNC+3bvsDZYMcGyBVqt5z526ofk5DA8NTBrXBLQuJ1eG2JEVUBJhwArCnT5ArAXBK7DWhqBGR0BoBXWmEkMjJCJqBIiRa0N4ESKr7AL4KL4MENAMEN4GsCxV3wZ4U+4Dnh2wdwHjhj5weYGYG7DwA4gTBxA4AcIN6HDDVDYh3QcQOsHEDNDfh6IbsOsHWDrB8UPJ2XvA8QOWHED7YdYPMDihwPbRT0gSB7TEAYk22gYNEV+GSFP/+LuSKcKEhgbFCjA", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "8255b123d7583268f839686341fbd344", + "uncompressed_size": 78584 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "3aa2fd61cc42da86769068cbab0f9062", + "uncompressed_size": 78584 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "5c717f1c5596474a9bfd80a26342ab77", + "uncompressed_size": 78584 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=16 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "4b69ab8a8634f8f194d84a88b044747f", + "uncompressed_size": 49080 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=16 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "02b8daab5dffd63fed3f6f2a1476e92e", + "uncompressed_size": 135968 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=16 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1dc20be8fec6bb6c6a00672beb6de51a", + "uncompressed_size": 119520 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f8c83713fa9e4410f0ad04e3bf7109e9", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "8ddc18f3876fe7d788ab11ae72383abb", + "uncompressed_size": 24440 + }, + { + "blob": "QlpoOTFBWSZTWXX3gJcAMlZ//////////////////////////////////////3//////4ElOd9ofaFlNffYO3hPd7G8lz7768huePd672jUbr7e+U09O3Er5hnKUUPOeUe93LwG6e5tuT3t9e9977x3z5oH333ze9t3uPTe3nt926fUvp294933e9007Pu9aPdtj2+m7qvWctDWeWrubR17u3u3es973c9Jzuy+99951O2D7wXu998Ointmht7hNrbkPo0KVqIaHTzYenoVWd69MoD3298q9vnY4BmkrfOfYPo+x766SJALevet6eAgVw+1DUITQEyGmTTINGQANAJhM0AmTADIGin6mMgmEwIniZNNNGhTzSM0nqGTTTRT2jRiDJqPTFPRpHkmBTeknkEz0h6RgRPKZkmg1NIEAATJk0yYMQAEwmJggaBNGgABU/RiYmpk2hT9NMKelNiT9NKeCnqPTRmlPUZkGRNih5NRptQyBtGoZo0hhAMEAGgNTRADQARoaAImTNA1MRkTGjTRpT9Bop+KmTyMI00ZNKPE2po00001M9KNNPI1NHoyZIDIHqMajQaA00eU00zU9QBtTIBk0AGgDUwjRBEymARiaYATJpomyjaRtA1MCYTAjTIzUaZMU2RTYnqnkan6po9T8RTT00yno0T1PUNpPT1QNlPRGTTT0QNDQaNHqaHpANNAAGgNPSRIjRGjJo9RqnpjQCngp7U0mEeo9J6nmRCG1H5KNqHkmnqNPUBptTTT1MnqGjRoHpPUaAeU9T1ABpo0eoAGRo9QGgAADQAA0aDQJFEJpoJiaaANJiYgZNDIGI0m1MAjaJk0NDTUp+ZFT8TTQPQQ1Mp+TSntKbGpPRPNKfkRgU96p6aU9Tam1A/VHmomg0NPUaepptQ0AHqBoNGgf1zkib4jYqcI/7p/N9iS3DzCf7Zv3N042O+j9bV5kxWdG+kMzr8qO6jSJkJIpCkh7d5abD8v1+u/5RTTEToEZp+R6wC/JWdjofCnUBhCAyFdxdyYb7vs/ylXKej6a1V0+WQklApy5HBdnnUhObUDJYuclCqVitYgwEHnqLKSs7zshFbe3o3zUOMOAJBqbfqZA6pERfGIyan9lnw5a8FfpQO9wMa7AhdIY12l0qsJpPi+N/8kG0PmNAvcfEqd7w9rY8ahJKrVfp4S5zADeb3j+P5WfB0SADhaZ19VxHuAAFZIbxQ7fLWyLuJ15q0YPP/R8+QW7YkpmkVGB/zfwfxURqsIOY6kPtfsWiUkmZbsQJHtqL76N27du3btCMSECj5VjxSzg1qSQHF+j38RILjEkXrECmtWrVqVIUsssstmYResITkEU6XrOeRElmeHjfvAgKZMTPnz0yJTjTjxPWUESsFKwV1qIsEsDAatATMqlq+ortbALLHZaoRMEYaM7l3nKnnxejpFO55QgofY2S2bw8MT3vR8DECeh9g80IKiINsU7C5StazapfbGybLluUCpJQJbYy02ErEjvMBTlrlZ6bCdsQ6zNW3yszPpJkkYgARfy95Rhad/LsdksAKvBljbNHWuHz1uy1Ss3lC/mZbrSwSpSrkmrdHxKJ4NHV3sz+SFC0FFP0Kv2F0hKKxFFP74/hP+RpAK3RAxX4iTWLOp9C1uNizrsgziFnGcGCMAyL4rEEBoUGgrMG0QagxtJtNg2kxpJjAYxtNjGiDSbG2wTYhF1yMIkAHEQnf6YfgPri0n0+SYKl8GuKmMVvMs2Jwpr5rdBAF7tEi20JVa8cO/ubu/3dMX7r/Gy5IkoCSh+OnTcZ2QFX2cbycCv9UULrAJQp1RICKixh6DIOkyEIfX8kTJdBibDYTG7FRKjagSBscJMUCRCGNGQ0lksCLSoQDDHaQRTSRJagIIvJFWEEIG37yowavmrGM+Xa66yyqq9PiQeJxLmtxOh3vR22KrOqxqvSxbxXf9PqdpLaNy7r93pby5r9Ow3u+1M57wMDB4NGBCgbAtaRzsTzyEipigOrAmBKU4A02t/8yVBH/2/ad4xIDwWtPoQpBW4ziq3RgsaTTjSFFQqC7qBLIglIh0Yw5TUjm1oAWGCpjQGv4sFTRPDbNWGhScOBK99i0RvNlwqdEoF1xZScNSBdqwSPsNFPU/BPcXThOd9PM6rJbUCa8NWJLIkQJmlF6jkSNOClZ0+jg0SKkh85qk1QP0HLhQCVqLLTCLDRpqB8x7QqJX5z5sDPlRZN4k44RfFS7GEKwj3ZCp17WrIsp1xQJILUwOGscYWqkw2x8vK+4gkYmzlBq6urS2jpxMoxKlmSqP2pX98i/hqsTeZ+GSw9I0eXxX/hPs+ZAems/nRTG9T1sPl+qf4/ug/p0JUnoP45yrerCLyYAIWjLw0envEPzmHWVbdxVkjDWPrvBsWJkKxBX1Dcjgo8FEcCeWUjg/KVATyuHqnQLrmnRVi9DIPk8rvj4S6HKyOVylVVltVJZjOaMQzNKnKN17qjUq5GQepoQIrpIw8oAHgoACBiFBR311T+16ddcOjormytLJ0wXu5HTiwRD6lbXicdXIM4HxvWW3X6n1cuqWDDzZuKs5vUvam32FTVVlHTU9xG6vyWvv8nu9mTyBfeRMf2qQT7vy1h/4iDmI0WpFbT58iLFiyIkSIvlVaVNddddeyM26V4A2A6BBEkxhLkUoY8/s3NKuajoJ9BaWZQmqVFg3XIFEIK13RA4wzMlgZy+LA+TJDsWfeRIO1LAGyLoz4CkIM7tvMsZl25ezc2rnNLSbBixYrM20GY4cSqclWYrIkTasybcnUKNKlTqVb9ulXVuTZ4xXbQw3tHQUGBPQLRzs7Ek2xXHMWGsvKf5ELJVyosbFPXlS5k2hTmTp+LFcpUKNKhPoWuuLoe3z3yNpkbz/A+D6aBcnbeR+t1x1wl2oIoAk4QxAgOkOrGICxcIgN414WsgPANybs4vjfdV2RGM2OdC8yPhpSSkgQ0mVUrimuRERWnW61qhF8nR1VU/YsjFUD5sXvMGbNo2b0raFyzz82b63zrYzOZER5mvyJPbczNy/k7ShhCvoszqXRp4asQlMnZ4oAYH7sF/Ub4Z+yupsrSn0ftYH3bfIFla5NMG0ulShMiGKAXEFHiJLqA8ZPucFJeD4Vqsog5OI3PJIkJEHDWE5QQnQzLMC3XxDO/N5ffs5fyIIUrvHCrDsXIK8v4CSVg9FxQ0hV3xI/FPqkgF4vRgVlXpx+mysEeH9Cb8y9oqT0p/0LCdP1uIcTH0JOPk3Tp1RbHdv20U1lq05h3Q+Ujokyqf0EIMK5mEGArGE8h6VyCAYgjo4nk8xfAvo8lhjQlgTSZ+RW7peB5MQBpNbLTHC5Vtva/mXG8tnW1ruHa0LqzHm7nwfPwq1ssxZaFKjQnzpty5nTpsyXKt9eUu8EPJ87G8LJhedzux1ew09TxfO6HnanL4HLtuVu+U4uN5ynPjb5b52pyfAu0HXlzhlZbcSBzsoQiwEdoW3uHTdEJB3QCHFmRnn3TCKRjGMYM9vjMzM0I7BqsIekzMzRjFoQhCEIP5MIQh5cgEqwt4vVKxvGiH2WsI2XZ00fGJps62SoblenI+g4FGfBqBdlY3aW9THlTP0DB1QeVaareViysWVm7ewcCHtc9r3tg9sXtlZPLMPHjx48ePJx48eXTzwHjvOe7R7dvbx7eeoad2befjp2eCQdkoqgPVRGkXSTAUYup6hpJ5l2Zu2n97F0FTjezWU9IMUUouUxrk+np2VPEOVFgn410uf2abKisjbXOIfHJYtxFOHDLoLJNnhsMNhGQ0NCuLKxinGTY4s6n9jH9auqNj6dNk5qqtNZWF3GK6rmvPa7k8qqnLlL+1BfYmsRxSdeG80oAgCAIAqWNDEOzMsawbOBZ2dfB+3P2/bwCAQCAaEMN96Kk/pSSSSBgKHkUJePjS+1vXr14oks05vanlnmmnZvs25u/pjWpjiTiaaWbnHo52+33M9nWmnAlNVQ+koEgMu53Fn4jPFn6tXwI1Qu1d++Tp62lPKdGrfdWQMLBs83A/DnQ3gYtMzdnoSyZ7WCHcBEORrl24FZKeQKeaxV5Dtm1ghtgYSSEzcGdbiyrRey2WyooWLiwxXe+3pzWjq8alHfbBjV17MDduqxhG3MT44FcClntSgdUmroN0BIA3Pe9BfUZ05HHx51FHa3pkxqkkRJlD1wlGunU4/HtZkoDHaEbWkcpAzLGxsOhx7GTwbMR4UANZefn59vfYKeiu4fOwMDavr7NObWNwbqyjUsOW6RMdXRh2xmplvcs4sS6699ZsBv+VgewMx5CotIUFF+gzzMZrpNN81hAAZU+PtpEuW60IlCOXGMURYVeauAE00opmks9Ug5/L1O23alDGhhT5LoGWZcBZCCAAaayAGdXDeMss8bMkq4SjTUkmjylNlPR3VFHLzcGavAD8AhbZMq2oNQagU0XZ3ZO8iogIFHcyRFAIMk2RMqh1EwxABP8E+lI222yQnnLtSc1lDIJXcNTo4eNoY+xIK1AIHoMShC0M8jL+xKC/ZebcBCmkxOJIaKVAlxUMMkdkEzZPe3pbjeHHM9GlkUEO7JToRy2+z2ZqQ4eDhSoyVnQJThiUpXVARGKdciIieXgg4AxD3rbbdq1atWrVqhBdoC3g5hZePXr16EuGTzzzyj29e1JX21zC0RtubUXX8UBSGGFgAQwwwqQVdLL6hEYjeG2mviNpqkBx4dxX4UqXHiDXj3qgpGm05+rTvaYSrLaqW6tuWYLZq8uIUwCvXTZCECEIEMBSdDl9GT3+1pCEfAg873cZJXR5MMjCpRElS5/lhHTidVm8c5WMyl7DrjSRz6Cdo6m14JMm7ZGufE3iUslxfbcvl5UuW7C63Zrrr5vZWL1aztOLxaXAtR17e493Q0M3N17jZWdtcO3Dhw7d117Px3IE1LUBQEDpspW+aekCQGfC7Ao69290MtH0vZ0mBs/1R4HqUgdF3u2666y669Wq11G3DMd1qaE1wCFvvow5ml5ye4b972/9+J9KupSwxQEcoJkMWDS95TF+Hpc5vlws4S9aRewaLpXcHgBjL7VbYu1l+6d5eMrtLHSKRiAClKClBSeOYTL/DMVYnFUIqIFUl+x1N20YGMLAzTJ9Tf6Mr63f15VVAa51u90mZqQlQikjkjIIWBghGiDYJFLchIS/ULxbatbNMKDmml9OKBHsxBPJs+n04ufBiBoAXlGLl0z4EUPp3Z0cvQgGKaH3vM71VyMkVu9twOOGY9v1ROjMzRicxtpo1wHZuQtqe0Enlam5FVK8bodCCdSF+3HRu/diMimmMhNMNNceCEwfndAYE1BTHOEKNq7GwugKt1AQx/Uw+jTSNQbR1MLpF1GWutvodnxtXQKgn7QvoKd8XJTFDk5Jd0qhyeTION7sePwZkuoo2ZnUsugcx8g1eNtpNvlPbXe7vfjGWsDTwEHm2zQ4ZvASAHdLty2CV7ssXNiMHXBuluiyU6WGXSaU086LKXlXgkEj0QtpnzUQooUpGUlOv94euKq0xTRmELnwrTR4fc3/9M9IpE+m8OwTQ8OMRGsQTfUgDMUHnCrVk5curAmyHtevlV61OvErr161aPSrxYgilFiOy3311EwzQ1FZ6la4nGRSYYvvz1OB08lolDX4mKmv03osF5P4u4zZWrNsu72eN3jM1zLN3u34rVep3+qwLiHWq9itTcdY6ct8rrb+RD6WtlGMdrwo8Duc+HUlJGuNye2pcFOfnPOOOb5RfB5GGwouNLcdNVvM2NTC4WhjJTm7CZurnbOqoyzn8Kp39nedVgw2uY11l97bmMLa2mvppH1DYge+s+Q4RIo8BDgaMxn5HkIIeXnjnKNXZuTsdnJHMjqyCP1mLq7P4rvjOi2KGth3m4YpEjnCzsNIhaFkSx2ES+h784xS+CUCUKl6w5xQQJyghxP6ldW1n8vT/l0+/1M3sOrWu2fU+rVz+n/H83tLP7fcw6Hb8X4nTPKdaNohaaXlYVtvGz2s8LdU9HI/LC0USujOx2fYob3jXnbjY2c+yOjvl/n592dOnVrvg+X+OxYl5n0rWHY9Gj09mXHkctWDByGzfxK/e9K38nyOzsdDk1apZ9QZZVdJb6af3f5Y6WlpE3OTYaL8sY5ezoiYuWkctEaMAtI5ez9X7smb9xbS18iRk+BD7fKn2exnGk3k+r0OP6HP6vvxMH0WMK29/4Fr9felr+ZE8mgY4pKOJ2jSkoaLPzszu9LaXnFuzm28zNuW+z8Pqcjkbzc8jaWrWxsTZuwtmyvS+ZzMOHDeuVsc1Dv6FCdTpkOiU2HNp+RJuZV1JMyXNhBuJ6nkQ022vxWYatwBFav8/vzZSL7t9omdd5FbkM3DDgjEi4wOI0Ua0lppSCPm+FVpW8+St8nJjFBAQm/KQCdKA+et+vzfsiedAdMcryuSPHivm1f6Taebf45nP0EU3oqPZUujUfwum1pi31zeJEkapTqG+wrq5a/P8783zNPw+v5/6Idzw/F7dUJNsTncsF5RJMnWRlhyej1gr9f2vO6yPz9X1vQ7X8mPe+Xzoj1jO62opmiC386vttIMNGhIhoCtCNCNEWghGjRpDns2bNn7MP88QF7JlD9383f+yy61clS/D7vS9lrCBq1I0agrUkg0hNTcyTRZNdUK05dOUwbSpUtvLly5cqllz5Ej7GVU96utIEgRw+GTChQt3KXmPKkJsGwbBsFlllYLODyftTqtmRlxW0Nmxdho7DsOxFrSG7ap2mc299GpDJahGZEIjRDMiiiiiit4tL9tDqUp/YVYnYgwKO4ZVsQoKmLhRWnaK8sssssT/wfsVcBVo8WGSrPDV+d/E+rVrFWiJ2sm7Q/RRdrxQ4ZQ4cwWcqi/s2Ytni5kmTJsQqH8b9aR9Ffq+6weLKKnaA6qqqqqqrpVW9cFy5/Tdju3bt25cuXLlSjKh0D/20+m7pUqKlehyqKs8886Z7VpPp91Z/xvssMSVZZXJZbiqETTCaaaaaCCDIeIN+tjLLRPvww7u3MaXKwev/x9fHzbGXXFWBRx9fQZdVmzZny3T2fc0/qfjaMWbObpsWLHb29N3bdRtpXjv3mVnWq++0GdHPpbmtZoooP9qijc169evRRRRJRWrVq1atWYrVq1beYYn1sB59etWrbHHr169ixYsWE0rEV2zZs2bNmy1Zs2LLTB7kjfrwwXLVrR7JauS+NxX360GO8zbffxXfVLG2dhmGzBBBBiTwsswKPrfHx+TWxuDTX2D5eKqrq5WP2TnJ9t6waP0Nm88TTSOVPbMt9I32g2/4Tkb9S8TNky106CFXB9iKNpRg7NCTs3bLTWyzOvYe2z7m2Ty0u8pp5rD+rUge9Z7h7p+B++fjR8VrFFrFXwz29pR3dnYfSlO9duZYZe0UpxNlFdd+nQ+iA8C6z66uuGXnnHnnns3Ct1JpVpeXh3Bys+9NuJJIot3CuvzadLKllkjiiPDsVI4445555008ZtXWUnjjjiDUcatW4WUltOw7SSGL1q9evovPrv8fTr7/LZSSW37LLLLNKaaaaMYxrRjGOjpwMC/v5kRE1Ore97+xs8KvZYWm7h44MOCzWWn1HFlKUtNgTz1xqulMiarU0KqrOqqrKq9IU3gd07DX05OwoLH4d4Ok4g9/2vY6HGzuBp5XO0tPofRx9fna290OJp9fffkYdEpCAmZl8TNKBF9E2uiQEMSPMATkfLxPNw8Jfw+l0uqnTp5h8E2+AAThQCDclGlOe8DiAD4fc6Mfawv52hkbT7H4P1d7972cXF4GBYSDBhACDC5hYA1BSCQEgaLDRysqO69jPzND2PY+FPu2WmLGYu5aPetWhpStIzblyKIIX0tE0nJsWLFj1mzZtCsmTI4447VwF60BuVgUg5fs0ntUNIkIB1UpgBjenACLS3uhdzZE2AWGkiZoPuWH9Sx+L6tn8WZmbOoIqsCs8ZpHbSlsihfZ4Nu9s3ntXlH1/s32lpXPs2BYV9BIKeF0u6qcb7NT2aYGIxVGlhNX+QrbcikS3W6u/X9zjYeTRpUdruM/7n2/X3cr1/nfr/ctQJs1wBokBkkAtJjxUsrHGBij6rIHSNF4yKaUdAQk0KFA98nEg20OP8qN1oCAhHknNPWsI2xBggaEjGr2bf0foep9L976P2v6+bZev71L9f4fZ/r9FT+inyIj5GX66uirK6q2MPAxOwk6HuIJUp6CKMxJ1lLiwEhIlASDYOUtGRHb7GNESRTaRONtBp1+Ba5M13hcO7x+nGPTr1wSvmCwHI+tx7X7X+TL5nM5mzoRXYXxdOdFB+z+3773ln8XkUhF+0SWuHw4IYWEeeisBgT9Tv4mt3nTuAdQJgFBSWKoxyqCBwB5fA95Xd3eshMXf+PNzE5j/CvYdlIx/j77mRD7juiYDwu7vWGDv8NGBTGeVm67bKIZHibjxJofx73Z8PfXuljs6n18OIoctLDZIu9ue03yjAz5IRRIYkTAQvFR6KQsh7rDRX7K0PlveXL5poXMOzY/dWPEXm7mHM7DJppeTvA0efO9+fn5+N/Dj0R52+m565uxUAmVBacK06IrwgN5rN1uvbog22rakD3j+QjqWP62Py1aZkTjTm6hTAuYGNAz0Mq12yykeh7+wEz397oWE+wrYs1M04G0Kh268dHk4K4RGdFHk8hUqU818IApDV63vtHXYa7tZkG0Wbjq6t3dRBl9tM9Rd2Z6zOhk5OLdVHxGSZhPTA0K75QwGuR4fDiFNimYq7FiOvjQUzR1teeJc5sOx2OjyeRKLeM6qO5aaadVAA6QLpCwKHntPgwbqLgb2/n8DQfqkamQD7ru5uqgzAv4Ab6vA2M3WzJArsCWWW7duzAu/7/v6JFJa8y8yZZJZZ5p8nJnAx91BFVo3DUlXIhVtRqwmR+Nqny4IyGZNaASvH6C/9JwKBSpUq6yVVfMDXimOG8bGScsxsq4UM5BOFOc14KbCWwzSMv1j9WznvfXe72J85B1aDAoKcvBgz9JRBwUtE8wBXwXrfvcgG/ueQrhHTna8Dlo/G4KCeyx7GwvIOgSRsUcIqfX+V6f5v2lHEA+h/f9ymFHP0osaORZgrGdnSSIG97vd7Uy/Od3GfO8nzpDi8+bLx1ebq4bko2EpW81j75+OpSQ+207WE9gbo0VmkZGE2QyTpwIqkRLxkC8lJHO60LVKmroO52jTc5fMd5HH+uz9PYDHG1UktsMPqPhg3opbXLucTY8aN50oX6K2J2I3tORyPIZj4x3s2mnb2e07bbrKsLRIUho7fnZD3uPf7Kux3974OFjPYIetdy8rE59FLCblfelee8N7WqYbCcxRkm7p0Ew5yEZ5Kd/iIQoc5+ch1JB4RKO8g9TMHze8u5A4w7AjYyzDeMx81HYohFzSgXLIZpU8ucRcCJDdXTADvL5UFcPn3NpfWT5fA4A9WcFiTT/vkeb+ze+35KRIM6RGQUhBhlIXEMQEDLNSpX+AIyKQQ7x7sFml3u9/Tvy9dUe97v7VkD+XL+SzBzYS4kkPXUJ7u7MOJkNb/E40fynsBsREHbjWypXfk1bVO3ZIl5RwIO+y/obdhxzIjf9giMM6DI4hZqgGaQm+Dm4S706nrNXb2/OZ7RUt5dtnO4dFKyG+axnhJLN8ixaWkZ8caZ6EVCupDA9v2pQiQa8jWJwcoYuvUr7+b7VX9jZ30wjR1rJxraGaZBoCMYhm+nioutSHRaamsoQdahx1U6T/W/jUFPlJRT/gPT35zG6/YdaTQBUgEWXf+eItApTL0Jb9xrGi7rTYxXzk+Mfg1QtPbrXsEq9/9vWI3tW3uiEREi7UYpf1RGTVIHHrudd4RgGCjD+7yoljibXamMID3GSMa+a0sK34vs3h3Pvuu6Ole58Tg80Ld5xb0UQEQEW6Q8tiKf1RotGsbs8qe7dh23cScf2P71fT/1WdkXfU9Xr352vj9jT7EtTENP2YBrNAv5KaSDfk16rer4JkGnMybSM8MMfUEI0hcA/aM9Hv+2A/2dbdcc4bjidzI7TiUTFF317iXVlkyOuVAG5ng2l5BBDhpDJMkJM4kEF9J4zY1XUnCUpdY9UwaEHBcMTxwEx8FA/Bm9dH5ncfJ4fc+j5fY7VVnd/FYRARtc+ugFAQEgpj48O+8fbZIBFODuAGpReyjdKtyVZCy7sM0GMwnw3d+dZMCY5ViX1rFx9uQgMknY2Tq/qL/NUHalyD/s2e8NOQvC4f+9VY+3vd1/V2T6XxlreISGiGRXXJubXz9ppF0p3ZDaE7bZyvXBP+X8utYQbZEPNOjs89sexLNEfjCtKEkYDb84RJCwTFeD9ibUeja4sqBgXqnBXrBelBSkLNgxikIQqA0R/lnBQJIFqPhz9Ww8X0LiQg7b+/EjW3zeMs/49S50LFDG7zsIK/5Sfw8L/DhqGMDGiAosuiJa82gl22/28JoYwqkL7YZ06o2BECUBzZXVv18ppAumkFE0fIlH1JAYo+Y2V/9Zf4tUQEgnwzb/6+lwekRApYNkt38415s5+FjQb6Nn/voO98PAqrjnqvqcYHK3ru8n5HOykyXEaa7DQ8WFufteXfgx/ldHKppfZbuT1oDZW3+e5g+CxrNGByjxeIcI771RhVmfQU4MDhrkxpM4y9ccPh/vZjlWVrg51GMakvmvvcLvu2uC05WXV1Wyo5ytlfJxaLn0fMqPtm6Km8yexprhc/w8jIyM+o/CHqZbwrz0qb8VnoSFMdQDk07fNzm6xv6j+m/NOLlQFWqXVJBuX0+/+6ScfWhj2VgLHNDVRQrkfCtK19Iicg+GPXK1QOHueR1V6QgCBn4z95KndnqL+5e56sN4GYxKrWGWFptK1JGYRgNOLg0K406kIo/yfU76K+9PCfc7mKi1bcGEsIA3hjtzwBelSkrD2FoM2E/6eYr6q3m81j1Tg5MHILjl+tEY2MRobucgGuCYTegYKFKujEZJVcCBEQIO/DK/U4+anryeUrmZPmFKOhE0a0hGrB7PL1z+G4KdXjeZmOru47u+waKSKeYJfHQKsksKHu5xaXnzJwf1vRWVWDg4I4EC6SLe45jtXad9a7Xp0fy+1c5/oZvk9q+SQXpXtqMdx/h93zeRYs4dbKcCTjVYofR673mX+f6m13WE1HdxYSEkJ0z8iDQ0WidklSC39I4VAFSLdkoSpSVqNk/0nJbb3jtLqe9Y+Yjocrl4UeYMsi8NILjfm7f7kgGF9S/C/aUGEgUeJAh1BKZiE2CTYfPmrb3lzdC5zubGbmGwdxuGq1tLTFbEQDCpFkx7KB6gJAP3pEBfyZoe7tUoLIxylH0ca9SqTyF/I+0nnRy6gxjkGwxKOdmV11eV7Xde1pPZ6nH9v6L+fYQt9Z1amZ0LaLcFtpRKzlXrsyv23HPSkbstj8+qd4nnyoQ4esw+clOcsmNqpUhCW9swPN/ehrzjPuhG3cl+9oJLaY/M8T4mBPtCqlzYv9B5ehbQel8L1Lyn7bFcS6y+H0hHn9KWekfDQamrb4NWeJjSTyyCxNwvRjNhdCzJpPJiI3PGxXYtqxYU1ImqyqjFgqh/iU3rH3IZQdrtdr9Tr+wbt5Za3Au5/A+I7FlztW9S1p1CrtZTw3YmzstHq+Twbzben4W1yvw+5spez+Z8exh20ba5BNpBfZ8WZscXV1+L7zy/fe/nFTxuKoweDAa4ldWOPPyK/9P5f7HwKxQp86CucytHWwYKLDa7nqSFTvpHE1O+uc/H5Kb7NpHI2q1Z/XRRyqTCDpYQtFwzSt4nm8SDzdfoNRgdHUrCGrVmOc6BjU18rM8YeLpMeR2YOmnIPk7xgdZELAx1hIjuCJmb9j2ENaMbqyCWBQRXBreBBgJjBdzvjuUb/Q+bJzuDUVRNMaOmM6gRvyQbwgLVBAFbkthhIlifYvJnAJw/cvY97LUc1Y6YsoAkLKDhTXQETgpaD7OdFdCxP9PqZbuf6Po+iuBqfQcw+I4tDQVbGoWCQegFmRTAIQxvQtKcYeKdRj4+Pp+WXVb/TbfQ3+wIBA2qwd1pL7epue/0cLvfserV9X1cz1dj920WtiCphewIZDRCxvGhkrPMkZIhDvehCspGGTZDMWgjuGclCUtNlIg+yR1Cknexn+D0klBkkLgh5Hq9eGl4RjTbjdpLrXRoOIYu0PF8/Y9xt2gZnRXORVNOcCkXK30Im1z8qP4Tc8rU2W5hj1M+nwWkxtgZDW8lp1BrMOctjUay1z93ZdNw7mTX0VvAVRt5hsI80LftpbmLLuboqbZyK3YQZizx0ui9UNToyxsyZUhBqIMqMxyHx4l5/Uuxz8aAxlXm7KN8VIUNOLgSpE0tvCcOJZs6Gv1t/vcY23bu1t7STY2gLBAPFfRGinxyACC+Gg65LT2MGj0PuXGWWGbqu959bCYBKzaPZRMkpGyKUibyKppZ8iLIxjNOO0olKSmGTPEchoemyaA8cYiW7fvLlx4wIERGAcgqU8aTe8HwnbGY3mpB0nMPdlnKbVtQKYDg2eS1tuvOe2MBKd5tVVKJHAwVIhfIzqtdAg3mgYKZ+fGMY+dSNuNK8xLdarKOHtF1izMG+/Jf5pQjNahWgAqgz6G43TqydTm4ndxYOqx1W3L9TPz+bYwEGkbszIpSqTInTkmaWoG8sJIKQkBTze5oycuSuTNtlJxCwr+vteXNKvah+r9H72J2Ue15kEANgIbINNpDYmypdha8r61L6n631f2fzqdnzaPPkvCSCgxACLguNyOrvM/uc7kaDdbGxa3Q4sxbaWJOtRRMAbbaWU4SwjUx1QkOr1VNGvooVRiJTJTStndhxzez7HSta9OBMlAhHAcn9hg/sXx1zO99LS7wwayzRmrwZoUIi3h3kK98yX0KiZh1HPEIQ+r5uLZ/SVNIudojIgG4QlkLnQb8bYAElrgU6UXoe/9/w6UQyL+lj5Cb8pEMBwYLEbm6qoQ5l1HBeWWWWjZrq6opB4XsS0pNVgCjRVizkJOgNrCk5w0tMz5syZWxFmwcz3Od7rxu7aGEQBnIzYER7egTr2awV8CMuDhQ+27bKVU09lZet8WNQ3xKRIkSJEiRKdhV6BbOWuOnxTZGU+pVCgoOOT0unAHsYpNElPiQeuyivWRXmYV5e3zy+e319hxWdZ830MaSBEgZtpIxh5NcUZkSyyp0KbDYCSip+XhX7Tl1fX+jzMPMLmHabtA/FRzjvQJxqz7zz3O+tJNsG9lnby6+bjck5jkDn0EADCpoHGBXdYde1BdeaS5+2E+HsW2evFaSeE+FtniooYoEZEJxlFvAAqu3wDqeElMyXxHiu/vFNP3YHnWZOp1OpvuplTZNRYLCOyXcdwc00ObzdbW1tbW1nLTerVrrfrLYaIfEDZx36EqrCS0tLu1L0W1VmhiuRwRERHQy/0ezJL0HBk01SlSvfCAouVL3tuluLxKs1sZ0EosSgx6SIICDERdStalMJO/0iXcff8WedTz0kRUjVGtAhrEqOzCdEhe62XaDxCO3t6JvQD0IUdoOKgUgQVx1GpXaAK98y2owY62LPMEzbYxkDBy8YZcMYxyoX7WNCCvFBPuen0+1w+H2u1Qqe3sRC+YbrdXvYvzLMQtkKKafewWPu4CrWhZHCByOoBz7p8XN3jakky88Z0eNIbzL2sv5SMGFyOf89/EIAnSK3IXTu3IHl1OPmcaMJokMmNVFJ5FAGhCeBudmGbok49U19bhbnqhDtpXvAk6+BWBUzhr/sAHZmZQ9nDEmlzrODgkAh1NBntDtek4vT7G4ksUiMuJMh221fwjmO/FwNWGTpcnJycnJybU0smV29br2bDDUDgD4XCuzTJtjFpY/Y7zvPXmVTMgLhdtBZ2fOCBkBRFEHOdBwTlSlW2V9nZ8r0/VaNNB3x+Q2s2uRS4OYzFNg4cOEjaeVo9fDxuTzZ0YbAbDBW/HyFw/selJNS7bH67lTlhXjFjcoMg16e2irqc3N3Iod1pPRCkzRcBCDWQX5p9G0tUIChrvdrGKLDNDe5/hHObUh/Nj774nR301CtqTUrRkixwsjd5C3MQTinldxy6uPb22X2xkExMcVRrV2pnBrLaheMrs6+To9fc9fI4dSngW4xbGEbfXvFi4tmBAgSRmh3xmxpm0NqcQHOdIUAIFQtjae/FTf3tDQ0PyxM78TyO9eeWOKupz0cMpFyNJKc3Mlv+rMSyigEcg4eCuCvSLHnukvgFloECImV1msSUhNUyLjjD7iOBVqvdwhYTwqgqjrNvtwVucM4cxNMQZPGINz9Td+BzOdYocBpQRnAc5iJtBtnj7JOEXHItrs+b2nN5qvNWVQ2eBzgb6jjePynGA1GIedWfjIzjp8jicTMs0NV62Y02lFDBoCqKhznDlcwt0GEshhw4R0Ef2C25ARiZEASaaabJRdbFEbmpuTkHJGs5Edn5VrZ+edga2Gd5plRIF1T41bj8VKc6bGDYuSTj7qMJtLdffpse++L7Vz6nP9toggdZQgT2xvln9R0zIy2Fd24trmxD3p3aI73xe9+bK25DuTnYswyBpxmy4ML/v+nuGYMBGFwimI3U5/maEuh6PttfB8N3K1MmKjHpRGjKkerVqoCAgIG17Z6ZiiadwZ5m+1ysJglMH9kY6eNK2BuxMQR3B0uDZ2so5c7y0wbV3XxlvK952ezLsVZgqWDCFfyHLRuplPbpqALAzW2UNf7s+PtMv4Vhbz8bwJnYiJbUx9RFIEcEvIpJqMK42/pc3l7T+ddfeeXewCzD77pyFEGVaSG0HaMernHo335IQKgzK3ToxWiyN1+B2XrP7SzYDqfP7bmbq2/Pm7+5mcDIEYAh5T10gEYByaG28lk45IkqrvXVSKrXrUaKvj/m+B0VujpaM7Dg52N6uRjVtj6Evz97mT2boNp6k1NfZTMpSS4qxRzIejZifFWKIIioIONLkCKNUPLtnh3fD4ra+hjIBjuZnC6UztpuPv6VK21egEB0eloZWHTkZMZvEjwoNdDPGenDvKtpq8OtYZ1dbV9xYW7baSlu7cbRziWmX+Xd0GFKY2Ne7rSvci7x9S84l7r+Lx741aZ8tC8VgizD1j1s1GDgQ2lfXuqGF9MiNJOg4RBbB1k1nC26Dd0UFRVo2qoGtKH8HF9t2amlu9fSKabReV4PB8tTLVNPgfE0sdlHBn2gA/SO30EUXGUng5Js/C0MjKD6IkMPXjNYSmnhdYFzqc1kdOknMM6b2Bpl9Y4YB+GtZsmEKwgsPHJDsZnEUsLKyDa3hMTEt7bExMTEZJo7FxMTExGewxMTOCnFxcVnioBOC5WO/7I8IgpKdGuaIIEKiaeTprGLJtmPHdtYio6cxQ/wMPD6msymr8icO7UkntK/L1cBWYgddAlpaI6yAIcphDf9rL4Mz5om68n5UVDp7EsYxMEru3uB7Ppyzvb4KPpv1dY2Sr+M2z7XLcBRxEHA/2VzOVJFlMuqaCUW07lcHNac5sCkj0jaVRMdiJ8O0OfxrU1GW77DK+q5WY7ptj1DQQd1I/DM3Tthuatu+54D21hkQt5k7O2/giKR9103v0pfo27gfzK45XeT95QP2er4Vw0va6NdSTKRUpbiruoCAl7BD9kXLzUvXK3cU4U/vinz+Fqx/qboMeX3oJyYNf4S6v20YwWhC/AT+ap0cUOv5FCo886bJzmp3fJ8BYJG5FZ9ZlQkjTFbn1XM5/g+ZY0EtBMI+rrphmv8dbmrVHzMPkgvwiVNA1Lt2WfbyH0W7f6YuN3dsuI8+mng9HRyL11j0t/FiPJYEoMd7Y1Xu6C/gL+TotX543jA/mGYB45+YQGlL3sIY1pBPG33Pk6gFI6StJAdN4T5ic3zNFVk0RPVG6LVpFTBEiJE5xZBmup12fuYG+gFkGwipvMzY7MZC+evLCprKyjyqLC3PgjTwffXb9+94HTwc7n9Tt87nafHq913XO1fA5qYmTrc9C2e500MLBMjKqnpsj9dkhtiOyPrkAcC2V6LXxOj17yjozcszDbLBewuw41tF7rsUdF5fiYwZmhiLhU/N1FaRBYwXq+c6j2DPESwY3vGQeU5jHAj5HSdW8RJseQeTWUXDdJ08RuPULsLwrGER8Sp9g61N2K+oophNmwts46rGiImKTaDBM6J2P3/nbhSS+8wxDeoQESWRSOMZtZeypcibKmTIAKbL3U+BKVkRt1RcuXLly5cz085cuXLlyHLly5c0rly5cuXLly5cysq5c1bly5s+9UXBpOZqZQrYs04fYb8FJDCQH56m760WPH9BkoGxeScamDfttnOwqeedkBgLZIQFaJ0jBsG0N77/J93zryFaQPhdCbnOV+U/owBI6zq1qlVzYmDZAycNCbS0t+QkZIxJ1hVXeYJWDceWHMF3vGmqGeETysyAk/K1VkR8WhLCzEVjNi8inUKk+DMsmGTgwYLVq3Mx8bzThALzciapXgzs0Z0bbZBYjTkAguLk+jrR309u22c5uBXro+O/hwAikNkdMxvqKLEJD8ydHmK3++Hn9DzlE8BIszlqw+PfDFPWsDgr9oyTtfeRHo9D7e16YO6cQEfQCAsWc4onp7tSYfJCmkPeDBCgUD6IMme9URERESmdka51VraWgIaQ0HPY9TqXvxycnDhQnJfW8o321D1KNi09a323addTHput4EUpIBAVFatf36BimKdtVVdPTvgTK4KtjUN3EOG7CBZQqkw0KGsgV9cqN+M7KZ5MqOtdL1/Wu9p68ELAT2I/xOdPQT5lCywAV5YhKEEJwYE6O2IdPUZwyp+feXk+pplugUKobC4OG1G0fLoR4nQPq6+oojEWiRIT9aFCeuZOtnLi8kBZMvvPcQSSLKOd53AmidQsETGKphVnaGuQnbS6BHwgty/B4e6J5HgU7v4+YqA4CwEHuKvjSmSAg5XflEPcRSERdLsfue+8+/KHiEGfM7OJX73N2jjspw63W63eeJc7jvptjPOONw1fZPQ+5lrPLXH4s3az7XOewpge17bbV9Xcw2lc9aW+3YXLR0SvEZwG5NSeNZ7TbJjnkqqtzmR2aZPSGABx7nZLOBsqUGiBEIR/ASXJfZrwlJw2fGDwzyQmZUt1j1Q8cOkAdAK/qiRq+sIk6wbnRGQF58HJU7//h/CADkLdy5zN35Z/LQg+FhcfDpxFbNw7hLXspYt5kRgHCExayd+qK6JGgyeD3dS+ADuqLjDhyxigGEBzAfnAd8G3JGOjVv8CcARwda58EJ+mI3+6NpNXAycpDCxv30kEgw8nIezJlZekyHaKnMzPHkBRqDaonTtz4PO63fUVYM6KgL6mqqAjWqe3r2kyePk5MxqDgarm4uLjjxjoop9lV7a2yqVvxxx3U1x/z8dXXks7PkcHdf2EkJEczFAwqFay66KFs1jQYbiogGhiRpjkaWkYWt+cGcl0A6QMBgoUUE0oI5YFwOUEQgDBKSwFLngly+f6AV5f7XyfI69ux6LXdwy5ZZIeAUWfD9GMWN12F+yOT0tmanBs7OzySqJ5JzERnkDF0tK7pdtpZfU7qKHG5NGo/Uh2qB8VXIHau5OVb6gAJJp0SvfgcheJmHCQBEA4XFXrXPdgJdt21Wt5AXsMUxvIDXxLDeStuNJg43zq/ksHBYPS4JQIB/k4eCsrM03Nzac8QxoUpaIjOeHg8/iTzvZm/9rrTEx2LYUm3UN1Ajux7oDUBgKkDBMskrOCjUjRUJAMI9MuEfN1gFANVoLg2u1qMdTvOrta/gdGW9eeMLT41tbI6sGNyLOHqs7WtrdX2VvT1OJmGAsUW5tgpNtOw/y1jZBlwMYBRRRRPcw6YmjCKjXNs5sfynIM7DRhRQDxDcYO25iaxJgiIOlteFo0nacG3yGMiM1h49gDrm3KSGivlsIj+dG3umlwF3xvDRZoDBpR5hnlhdZamAFxAqoAGEMIMmc7KtL4oFgCpvcaZ5uCQjIbp4UzKsb2x4yqWNBJgRg37mtWrNbzbhN+FT4Gajo9vDisrTqEiBbuHMyJE22HAUbVoGcjByefTA3g3gp8NrGY0wL5zjiy3u1y7j/Bg43hIgUWT9q23Mw4OIKYEEQutxcVBEkyHqIs72bmY+xVKrhlGRFbZWV7Ukrdvt9vgMcFlFxU/Pi+b09PT5dPQ2Fzl5eXl5eZliVl8vkcvlxnCmZqdnzGuhWgWV28dl1LnZphQuJqZymmFqv3S3uj7VuTkzXy+WEhwKhL4oOb+f11ak7FvpU5PDAxu5AR0QFm2a5+QOTtUAORMGl4jLdTGQZgB4gHEwa8/Ws8nodxp5LyRgK+9gTGXi2wW0hauNtbPy5fH2d+x0a6uarCAQ5luEcQBsYFlBCrAML29zrpBHKFT9CGJLSLtEbUCIwMDAXQ+IIYHCLTyhz+dfutaHPIIhhf4WPC4CVXmA1NTQNUrBgbmIAi5GifG63yOoiPayV2ihO8iPgvq4FUyRWiwezzWn5jN8DReU4CUq1ad7fCwuC1JfsCM8l3TZ4WbNK/nXLlrOk44G6NkHb31GOJkhfv3cYwViY4xybHGhg98wgY/cvWOJ+Zmxop1utMIUjZBDV7jt1Ck2uMRJCIbs4bzmpNzfIkOdSc54EsMtXIGiTXA0dvw1aW7s3EVIbvgbDtVlgUb+NngVZB1JWNN7P8P7pVYxlzm+a/mZeVlbjljNirmnOZPqc9zsYuLsOXDA/z5XNwkwQgpiBDByTqcPVbVTgaUzs7NzXIknaIIkfUUNvVNOXgVmqpQCA2VlRKVc3E8T7SfVevGrUIA4Qy0KvPJ6gkLjY7DLZZWWY9VWHTy0X+Bo0oFZgcVRWvYWXl5ab11IXJsrpBO7P7Tx4GMlcIDDIYQOcopoq+4jo3FNQydzHaI8HgtJWixc1DmKczRaEzTGdB8HIRAxlLuv8t+BXSXcRa/U4uK4UJwyORPTVj5cHWLpIQUlBqszs/gzonukBjQ5mRZeSrIPsMfrRDs8ta17XtENw7DCtU2NR47/p2UCKvKzw1eVFScwldtZk5z+2zN60/dYq2hVAzCAa3T5p4jd0gdL3q7D0XnXN2tYnHR7jHAM7w16diNHHnqVFE2HWiosyASOMa0Ba80W9Vs1udj3Nuk2ah4RUCfYOLKQ/K/nGMAGjJiIYMYzS8AhL7/qfZgVlD2NgXbgDVpYW7lGqZ0gPlXWiOPqYzFoQINCAir1UzMSFlDItK2kxZJgGZViLcvaCDKy16ieo3ANpgXwEQGbS08boGQsz9J3uMB4BDs+vvmduJimQrDOOBbWbs25MyF/34XyQLWBbhsUuDAadBqHJghTYNp+hIZIdwAmqBKA0qPyfjn24EaK702ZyKloBAM0DTlUdWBA5yYlg2fwk1qa40Nzju2r5FWstdW1IwAGZMrk9BjRXJkWWHUDHCgMPjdU3k97XapAkbwGCQwwQ34EAGEAgEAGBhBEMMPdBMArPH5He0BQFAMDkBEIAwiFAeSFUJAJgTAlBgRCYJAgEQYMJggEgRCARCARCAMCARAIBMEwFQBShIFwLGrMGB4297uaTq/A7UmWkz5Q8VSYk0A+bLDV3ezjMK4eIQt6qVlJZiX2bMq7wwFCW6IyqwJWjR8UAAYq8Vz6rtf4OFqMnacVnTFsSOuYniq2ryyzB8QgqGKnWa2a7C/kcHA/A2SAF4BG0AvAd6jo2Y9Puz7gocQwqGTfVJw3tOnkw5WYN0VuGA7piPWxQNxePNJ5TIbAZ2ABfZxfrH9jy+p/f9n6/2HGHVqDRLjEdsQAgCCExQCSBRd0mHZwPI6nX8vjY2Ti6tKjfMtnkhA7j091u+fSjt4aiqZgB1gYI90F7qRBGwEgQA3AHlHqEoXQvcaHfRIJ3nI580XJCxq6pq6urq6ursHLeVZorwgXmrf2XeyUuoyimtNz6mjqgkSw5WrqTklAQDx6I6Ojo6NzOmjTAnjxwZ3nOjJksPoBv9xyg1+V3YbOtaaLmG0M8ZHhlczSYOZAW3AXsfGKbNxPN068ByHpatGhP3hQMcPnJKMNdxPGLwQ3lisCmBVgTACAMGAwUQYQBhAGARAYITBgwYMGDBgiIMBgwF2eJ/pr4/TviiQUBsa3GBkf42KOcwlwKShrqLjnkpKmMAESYGL1JaIDIkmFyXJl1WvDmXLM71vd4EDTDpYjB4+HFxhH1w4Msno+PdmClT18mr24bYNsAs4CUCADAiGgEoShhBaCbI319xurc5Fkg2/vpCZB4EGfP/b/B+v+/7damTuKV2ZgIYIrM7JMHI0mOB+q+Xp7/7HH7hEV8AKZioyOZC6+P+DezGeyztCFYhrEYiMx79uiUkWQpZs2XmuHuZ7OZLeOgG5FRx65ejJjhTbBpUqjJNIKhvTEpWeOBPjSm2DjSU3tnCUgeE1WGRx20wSbbGxtIQ2mwbQmNgmkhuc+QujgQIQeA+CBQOd/yzd7kJIgRODAnOLUS7nd53jRnbBtXjUGuY0Hmuubaba7TNw8DM+j6cdxuMSuYDtZmBljeBgUulLVGRyqNnV6ckyrSWwwde786kEzSqjRJVVMbw4JslUuU497BBs2ot3AAcGDgAGaBUA8XwoBSsz2ThB4+0q1QDACHmhe5saGxg221fw3Md9pQ7mcgwiJEgRD4XiQJxB2J0KctzZ9qCl5eaKTxzjAxEaIRyNOKZ4OA8GyzSoxpseidVywFxBmbp6sRgwJjdYXelchaMwRAyD70sfE8mrM97pp1tNsC/kKvLHHjEEEEEZ8iBd10/vKbcOUuyCIEYXGQGm0xhj6H58te9CkqV4FRbel3e43G41glp1fdVMiRFnN+VwP8Eb6YxGq1OGHfbWTauUOKeXrmFly3KUBUMSbH8vFIBKyAwJARccYQItQaXf+9/M1PCx/I232vgYeJXwr21GxZhFmrIfJ5kCWvDL2/L2PpYtTPopiVYYGpDR4cP0seA5kgLds3pBJsvJSKMqWz+F3vYzv5n82A9rLU0DzzBYi5hSkHmlcw+YXIUOUyUe3UAaIbHkHos1TmQYBY2VW22RaxtrgXQa4VyJLrp5wASPBaUw5dXEi8CRAyMiJxa3azizLRk6DM6Z2IwsNh0Oz6HQ9TSWtS6tjQbV7T6Lv7ZI3qu4yzgBIEZYhtam1fcyzEXBrM6/g+tLWFwRldXTsDAvsAqkYlUAGnmO9g8Tyv39XAiGJwDcTULd9ifXJ8wdZZeJggkDFkGLPi4uLi/h6LrxAB3DPe96U0gUItMpSDRSZlTMdqQv5pCERxPugS5mXmUqvXU4kU2JNibM3Z5q0QxkG7IZWOkisilnLJ+IukGwAm4UHZGdGYALKq/C3kpNetKls3xLKr8Y+U98Wm9EpnKJoQgADHCZkQpGkR5CQisvGYokIo1gCAwbBpIvoBp+AS14BTgB6IAc4OeCXWDnB5IYoRqgwKDZVAMnY3nVPih6B4+5s6F+GoeodBB2k0n5g92HmiKh86oEBT04QQeavpCKghiIzIqg5xEVUXyyfnU4QoISFVKuQ9sRSlUwZeVnAdHjRk5UNtTbHAeUkhiBvR5LWq+4vX74TBRPzwfj1pS+mUJkaqOy3reTblvl5gmhC828JUnc2pCw9miBB9HbU56Flkps0uDucoJEmSntm0+6s5i4VgRBK9PBeUz+rs3OjQWSEC9sVfOJrFekHwgNGzgZd1lTeYqAKGYgZ2d8DPwN+qU+dgV3Wl3TmxyF2PlFH8YAt8GjuJM9xPcAe4guDGQAhEYG8/uBB36j0D6163Vg4/PRw7hGcnHQ3zSDhxciMW9qfYx/Bz99sSZ1IlDMIJVVlZUojAEUBmC3+5NsF+GSI0wuC5Aj4nl8m+yDGvo7Oc5Mb10ruEjM0dGx2malJvg6e+wa3R/JfSX1PdpnFMor7qYIFzgmuZW/kSmSvUp6qW0DJEpEr4R3/snO4kDxqoj5AbVZdfLzhFXz5NlFbPjfG6vg99d6d2Jd7tXrb/CMNMAS7tX5gMMCLKCcSglaAQAvAIHAqvsgGCYuQIxuF1s8KprFr7JIGBjV7ngFm8C7r56v+qFoXdm8SuBpBrg0ZgfSRnsOAsSKosqUJA4YYCWyLaFSlw7RkgYItTZRiQaNH428fOYjk7T6A6ea6vbRqUzP5C0R4mFCyDzBBAQQs3IQsdC4PReuWWiwHGpoWL6/6fWia3R4+OWb68YtjrfTq7xHPLuZzP5nKlFULDJiyhjGNuc6k2p8yHMYKNoCPiBzFvbiSs5CqQo1BL9Nf3EtuE/S0sFuOYHvf0pta3il3nPwtjj40lWeMHYzImX6nQ9LB+/1bxgKpVc1iB3C3nXU+nYZk8eo6SpR4fFXo0YM4TuHFkLKujw4s3CpYo30UavlECvdpBzidLbxzt7F6OildSjY6Smby2T3XaRgtzJYrDP4GUrfoXm52n+K4Wq4Izdq1h8CJpSl2XBQpKZJuuRnQsY+StMbHnasQxj4omlnEwcRJiTJ8IxFyQK7hDG8X5XvRHTEYl7X4dh32jFRgsiPLWMsLlUdwCS/ofagU8iUzn5HF8jieR16yL2fsZMN0364JAEGCe8XT5Ij4vJ0EmIidh9ivyTi808EPEQbkNoIp9xa8aO6rgMGIZeBYqB2RG7zxEpSA7YnSW3MVYUJ9z2ZMA6nU993+V5+De+AeBGvrVjMH3L2BPJRfdst7jB+zwHtle7rlfpIgQwBzu/5+ZadPxUP0pDdpJSlAzwgaAjWWg18POiIkEcXf1vjb6av4fzQNi81/dw9hl7gVtLS0eyWvGZNvN47y1W+OzQ3PMc3CDhVYKA1stkaUmOI6wlX7YRqU449yzXJlvJt8AbMqBo9v49YRvhL0PU4VstFaklSxP1su36W76m6+F6W383V+dtkqUSqZYjZbOxeiMgJccIheO97LwK+MIwJdL0wOAycKrF3GnxZ3wU2CfMnEOYWYCsl67YqkAillXlITw5Q1aGWWBtwYGGoqAmGrlBiwJQhIGKIikSTLIizG7iMwiiExZJFUvN1T3NYCuOoNUOBfVf6+X8r6fF5mjUEsZir8D2dx1fkzU4S//falLi/ElKb/D0qab/TMkXz0VZzRYPfBgpvWEGZmZmZmZmg9mZmZ7QZIKr3tGapNVopqVVqzVI0VIzyS44l15JHcdcddXUQqqq646688lLz2Tkm+Jr68cPJ5XLZZZ1d11/J8nS5P8fW4rMj0eAJG+xFoiNJeJIXolzZqu/5/H3mMxI1FVKm3AoFKQDi0crkcgNYN4HEsV/DEqwVy8kwaxfO9vMXDQSZrT5UKXdwdPhxJDNehyuDhHdmNy+WR5dQK+6XTBjfM/lR+PUsRaVK9lkJ2gtNKRgqExRf03N3UJu+kplOSUDIcIwTlOKAo8dEqAIb0kLoInoBtDuZ+Wzz2dyALlktfnY+OFaiNBpQhND2LkSuIvu8k6Qae0O84AVbEONuacIQBbRsaSBtjbbTabGwGNA0Jggti19fX19e1vdficzwvKri4zCXFIpp0HXAJF3zd6nGZudHfgO2YvgDSYJDSZNRXaYcOGXyy8vorDvZONe11h4USF5vt7z+zhxwMBbAjm3kZAGFTBpBLIpQ1y+NyHcpd4i1vfPBi2AvK1SqG/ia1IwZQ4NTZng9DT+f3fCpqd4KqM09PT09Pyt52dHs8Ls77gVyzZCGSIzEsxEgZYjvAx0K/yDMJ4bPOBkBFJHFkCCDzr84PErpcxm2nos4WhhSylbH2hTCdjy1NZ9XqH+M6TQyTXbt6vrXRdw5N++2aVkjoCU4s20ba8MdenGXDxc6nJfM9MJAhjfBC8UgpoGfMnU7h3n75t5cphJ9MKizQBwAQMEwBNxgHZoOGB1e3WCBB7jDVhi7du3cpjdu3dpsWltqjS4Xg2drb35mCWSI3AfxEK92/yA41IO7ZrWYUCVXSNbIWkq4e3z0lSeWnpreQkd/UXimz6uvBv4hwl1kpzq5uLasodH8U9iok2cfgCIS9HkbW4frY+Bhj2BGRzdgU8HpF5m3o+10vDSiORUx3C+H1Pd33sp0eDGF7xf3+JzlnSfohPU3XtkfgEq8yvB+dj5yfmW7V72tVNcSioBvSBuBZjtqGczet8FZVz+8P8ZTctwL2eMIOhoMMeztWZ2NxmF5e5DTFEZxBnY1n7kdFAy1Xr5mUsWHUYMwGKS63BWMssHVRfLzvhRTtNGZ8SD0PxMlm3n2eseapZ81uA5fN28DJ8zF3lOYvvbr3bOH7e+4tQ7cb7H4bdVy7bDHbNX8lzN27v0BmSCTG0qUMLUIhbDbbfIajgaztdwOOBxxyL+jTdZYDG3ZZZ7ygzOb6DbQZ6bXa4tX49Lg8HoyPfU/qfD4fffiMx7PwmBMyGNvS4PE9lmah04vsEiGh1YUs8CrpoDwL7VwdB4fd6Xc3TOZg13c03NzECLEyMzMoELk2ZmZ4G3Ye4O3zHuD7GFO5e4PXwLU8vdQEH3OyrXXsC2u3GhlXm27nuwYOOOBxxsN3GxA7dzmg0yywBElYLKqm5SqgtWXuycLCjGIfrw9+fnwGf8iLbKMWDWW5jY3OZLRC+fonbvc1dtZZgumDa2lg2KNZGIjCGNrQu33A+BWeJ5g0L7dsGDbxmzICA25655qJ42mZvr9sKeQiIxjGLoxiG7V7nveEREE000020lGIa8jGLTRi2XTajTxaozQGpZhB+/3vAiIxizW8BDGDYkXEy1gu6peuuHDgI5Ns+d4voQhCGgwZmZmsyVVRg6m4ZBEkIC2J2QQCWRuTZXuy+q8Osv5zAhYbRA6inPQbFa3A4T3vfQqqq3mvDh47aJ9kl9FUlBVgqojADpbWbZzSjHYTIwREJk0YQOKOqn2wln0f9ZBGNlUyr0ZSR9tiWLlOUscPNzZCSzBY5HWfT5zyfncjyHCtce8jUkd7F0B2IveHYmQYixdJodaYWqrtJbtqURAl2sRvNGRZRmhFw6n7soqKSqCpTbmN+mbuHcHzvPseHxX/L8TZ8hk0lAGFR1YNIBg756HmS4nb8Qjik5N629j+E10NscPTdFt8isC7BAbnB6w9WoTtcNPJD1QIQCqVAgqxqjt6a304CjooENSj84BCFmC9IABcLzK9ds2ViLKZHlsyMClFNH1fRuPY8YEC58JbiRoF6x+5Yg+pF8PmDrkKRBpHFBw1KEdLjhGUYxoYs/qO3S6/qeo/HoBlLhIhAh0W8wADxFrhw2orxLSKUvmnjbJvJ5ke95vvHbNSnqFo88oJHQNTUmbLWhu15srVS3xalU7aYd28bHoDqkp0lAkpl9jA9nJTiU8cd2DN+pOWnTkQMkjETFwcrU7ENincGkqbSJmISbQo+BUlo1ud5NUnPi1B2Pf1Qg+EvGbRJ0AUxzpNXTr2nX8lNuBfwTJe2pOpNP69bRFl5eW2MQ/Di/rlEBRpo3MwJUP+GzYFmM6DW6iQbwxZSQO5V/KQVUty8fTKsyRWKx3N00iQ/yFYB23Y3eiox+6hGIQrEKCHvivl43lVfLU+LxvB1VL5QyAD2qF4xoioVYL90y3FSrsHNLqJhdlOQKTxOW9yIWT978XnZ3mZ/meZydbW1t5sq7je3p/us2SQpAJssICz5CkEeyEfPRx4RlpExtbxX3gp0sV08GklqSTfKe8TlFMUkAUjwonK9Ydt18yUvPrLGZR9em59Gf2KU1Man4urgb/oY+nvbovE18Lh7fa3j+Y2Vg7rRvy5EuJ4NtCZckSofjLxe3lPr7lZkj4bL9DdSQYrpsEeU0Go0fD1YLd+Ju4rsmZgw+NkfU6/v9nsUkUF6N9finbtRvq42DGA2Itsg1BaalarRgr41JIZeR83D6AIW3q1PLhJ/RL2XzO5lWD5EopmCWCwlovKFDSlOXyKeHw6Rx/tURJiWIU9WASl5CZwp3sppMRMy1SgNqzI0gZNexKlOAEt58GfDyFDApFNl40lTujQxiFASbQ0kk0ID7ljdRJGgFYZHsx/PYdL1od1SPBpw8H60WffkfeTxEpWeWwbUDejElBJYbXmMP0xaBbhuNbca0ilLqe+jftBIwNhog0sFgcd45bgvXngfeYHmNIwTAMQTIeOQb997G3RzfadobFl2DIQjnPgMIOTT33VtD3Woo3ILC5czPh3LlvF2G5RUcY6Ns4d+/YJ+J4WygOKSw4iF+wkkad5KHkkBzDnrUBkSUBv6gpL8CfJ9/yZU1YsteejVEf4EKAR9vJVJ5iMFesr3YeX3PPzfLv1QFhzOfn+25FnhWbPsZlhfhROMzKV6bmL978HMQxmb7M1yFrC5SCgN5Xom++0ZbPN2u3S28/5crtLUIVOZJR5u94Neqx4OXVyADSKyZ89tQoe9QoBl9L6f0lqrZ8xZUg2h2wy1vFXfkyW7brjZahgsXZVRVIAAdAoHOSAGf38tMZ2gQKEF7Ro0F41dtA0aNO6pClpRmKtfSgNbvdLkCEI4BSgoRg18HUzmd2EqxMeCRECIqXqo5rbMMFdNIaWPIkSBHjYhyYMGJh2jf6D8ofrNCZQ10ioKAqXgZm5evcddTrGfV3W7nJfU3Eds9TG3B16yLZXl1koTtEaTF3JyTEzfD/L4vQdG42R/s/NtU7lGLxNwCsbj6zcBNiG81iQDGKGAhCG02wQxwkxQEAku1X44QJS44sHnIcw6shUUUiiARQIJcily6RCta7Xa5rOnypdCfOg5VChXfZ178yUajtur1F0oGUedCcib1trtdqvm0oXTb8b84+xAgSMZh0Oy6HNWbLSZTNdf5sv+H1+n63eLQhAVYoId4QAANwzCBnFnEg4IExyxBiYTaAKbdYmLjCrjY0ahOITG9wMTEgBESHotmqE82JGYLLVITJQxjGJzDYkOajVIKOaCcUik0omAqUeZq61VSQTluYEJOGJAm2pcyqtOK1cpkVlUo4okRSrlRMzCakkmxurCrYipUYDAhKgqEJld/g3t7uZstW2rZEjYFwBy4TIuNwkCSZC8I9/7jXb6932+8FfYmXSSChj6Hj/Aycn9HbNMM/NbJInr/ZuP+4H08Jz9B3pu+fh0lS50XrIvYx2X31gfnw8L7bzWW4uozHM3/stoVLql+XOlPGGex2exOeObMo6E7+d9O7m9OOcMyDc5ZO6cqYxzp1p0RjnUHgD4x4YyjK2Qbo8+daeOPQG3PVHrjqTqjdG7PWnZGQdoeeNwbg3BxzaG1OCcE6c2y2WMktV7XYTdVQi3wZ+wSeMjpJXHiWFvf8uzFnY+OzYMLQ2onjcS4l9D4DcczZ3i4uL6EeIrtIce+ezZs2Ju8o+mLNsrVgDH5t/0+1vww5uHl5tPmzLvFfcp5agzF6lSn1h3v/LseV5Ay0YjsRgSKnvL25Gf0uLxaQHWp2uTy0+9dz3+fkHio8SzZxbP8Iv7yt2AE9DrsvL6e3gwsaCqoKu3HUDdKpsNMCdp37+lmjPUzupuOrkQNvFrQDc9k5QysTxkvTp0s+phy8/Pl+k1bgHIGcGIcckiJwdF4cwNB3zQoJtNCXwdLLyzSzNLGqZwdGtBVQrRvLy1g7Pew2u12utM97mirV8Txe+RzwHPuWJ/K7PFjv8jU1LGR0e5Z6Cu5xd6008+W9iOjZ+e9gHl7qCvub3Wunp9QDWyNpkK96zx+AuExAtZlzNTU1Cf4fHYCz4vRypehiH9HL1ejocSBxqSzBb5HrgR48eO48aG3je2lo9q+EaM9QxpDTjf4+of60PErme2WmW75upqlauOznP6PJBAiKD3WNOsQJ+LFQxScVCnTxYjwXT24Qt9b/P4Bp2rweA2YL8TA4ewkqo5rWy9XV1eF7vDzFvC53DWwcmOGN4OGIhrWTFvbxagFKp/8TbcuRiekQlH+kMS0dHRKhKqIHfLFyRAzffGuzdN14h0bO6SelWcfm6+iGJK8lABAIZmW8W7Ti5VSdOnPdnX5PA7VIcDRpKiMVx/2KeeXb/XsZWVj8Pfb6ouHT0m2f4rc5A5h66dbx6/sVxYrHmHsWIiEjr/KsCzvl9q4zFzZHCVaT20+fwXNZ9l1vD/OHxKw4Uf668rrP67s+3S/ASfm/kwWtXjtNXV8cCuO0svY0zBXiPk6tGlHB7yXP30LIGTWN9YXcpptAQeQ2XmJJSOXl5d82E0w3xa+vhScFjEEclgpXb4P6RHBPQyB0ttOIkSROz8vQz1kPHMSyY5ckq1sgZEYRMKlPqqH2WUDjMxXUXik8/J5HzS34HF7poIYjiOPhgIoonRnye2mO4t9/fVVVwZ0rBqbGD2OzHLHCGQNPl8vdzxPnz8g0O7djGie8cJpi9rIokicSDsOWiIya8aNGtW08xg8j6WW3Rt3Fs3591gzuNhchKe78zas827zY2c0ybVpAIBAICPl9lt1caWg+5GRUQ5EqzZjcGzZY2e9HejIC25G5EWMueHArzYppXZfNW+LY/HBEL3Z+/cNej3/x8yWlMUlvkrKEqZMkoZubm1r9IUrrrhuXK1N2klTrqijcZhe2l6ux9Pf4PwSou+N0/tDRj6f1cMqVAhnWYFIjxJDrPzqh6DXwAlqxWDfuKlhkyddyhm5rMCuvbj0XGPdQohGg/b6y3KtRXKMCMi/QjWrUFC1atLWrTd82tS+xsdirAT0vhDK0brY32etHjRIYY5aVNWqw9PbMaNFuZOy2TINMdNCaodAr4yZbbmx6KjVy4HMfuzAGd919UDoB/C/kpsH8f7sbj9j10B0lJgO6XGTETq4WMezG3QKEuRPJ7kpMxtmJvGSyApGkNgAP9pCHbIUOIREKQKEOWlsG1AKAWj17hKSBps+c1stz4vi/gqDRNggxIDluTzakWNkRQbS0LPlKnmpC5UuMUgRcS6dVihk7WmDA3H+qplEAu2fhV9PT03c6GAc+z7QBuVykg8ANerPxBgtjciCfz+rk8NNNoAZS9lcUou/BN+XaivQBas2bNl74FrqgGiMY3t5OF8uHs7raPoQsBQ20Vlj4HnSryyyyvRGA2l8WvsprHmyZNK9AAzZCAnPPSjPPPhzggARCiYnp05voRyrcHkBvR27zsKQgWY4tK/KSpkqZOyWSUavTtVccrylc0XtAfb7Y7n+wEM9wAJLly5clJj9yAlOwCeSDkgkSMLEstDJr+lSCQakdJgSe5/BMTRSRTaAUYscsIRARCEuZZYNxDdG5SBQ20m2mMhJtwmMSTEyEmQmJQNw24Q3ENuEm3EQ24UN3btFQoQyEyITFDIiGQmQkyGQmMiG2kyGJMTIhkMSuzMshMSZEMSYmQmMhjEmJMiGxshMhiUMiGMiG2mKG3EMZEMhMSSYkyExKGQmRDFEJjIYyGMhjY0xJihtpJREWoSBgkxsAGkJDBIYANIBgkLFRt0xPY48Rg06+dhYUswyYYNjamaG1sOP6mH3iSSHh4eHhz6dzDv8DU21m+t3327JKufr0pP1wKZ4BAApbaM7kAXEYAil+FTYkJ6PHz+1JSq07mBLnV/WQjr397NEqOVCYmNttjROwUEMaYAUSWZrFiGfs/kT2Ks15Y8jqe70fhfQQmNjY0CGMdNpEGCY20NoEhEIEhACEhIgEIECQIQgQhsaaYmJiaBiBtjYNoG2076CCBAjkA0GHFHk2uLFJI1J4oBxiOOcuklT0gFQuEb8qiPApnG+5zK9e/8TSZ33E+YtmSYLvHEAgQasRIqQH5Vy/9sptYZw38tl2CCCDdshlpnvlA868h4gx57Gu+++/2v6fb5t7wpRjvh96VEkciJFz+kx8PlSySSvwtvtVvhVrEUccUarZNNttNqqMZ/j6HufuM+KJ5rlv9OtDDBDC96RgJ6TcHBxiksyk3Bzp555yX6UcRSWOEes/M+Fp9vcZ25iVAUGGA1GMIEEz/l0QFghiCkgkvZagME2gG0Va7twq4hOHsy2OxWenrHGbK6OmS7hLYM++E8AIF43HQiTBTydN8b3vurl7SoBIGfWGxgxgwak7XzP/4u5IpwoSDr7wEuA==", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "fd5f56fb4c2e301659696d054ca7f1f8", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "593f6ef60996fbd698acbb9d1b754dfb", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "e6544c727698e8110dd4917cd5695bd6", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1c300a8b8f9ed0ac68a39019d9842038", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "eefc7299fceddbabedc52ae8ff757212", + "uncompressed_size": 32224 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "c0df9945ac6194b68be739a3b07cc65e", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=1 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "bc154ba393ded5edc995dac1b4b5a7c0", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "b15584b2f35edb33be8f345068b26269", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=32 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=1568 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "30536261c248626e3c8593f8135f8f6e", + "uncompressed_size": 24440 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "676ed3b4a7b43eea908136605de89448", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=32 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "394bbd1eb532b2015c90cd5c93b84fce", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "810daa314a8028d3063282fd8cbcfaa1", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=128 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=392 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=2 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f64e913d722118df87869b486c81e1f8", + "uncompressed_size": 49072 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "84964f9b35beffbcc7c4982fe4e3c373", + "uncompressed_size": 32224 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1fc7625b60dbe46d21949dec1c23b6f7", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=8 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=8 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=1 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=4 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "1efda2582a0d2ecce7eed201f5a7a85d", + "uncompressed_size": 73624 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=64 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=784 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=2 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "3cd01bfddf8a2febed11126c12a0031c", + "uncompressed_size": 24000 + }, + { + "blob": "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", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=64 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=1 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "f19b19c70c7df67e781a5f96753e4526", + "uncompressed_size": 44512 + }, + { + "blob": "QlpoOTFBWSZTWa7wmp8AMBl/////////////////////////////////////////////4Eb7l8MBD68jcpfezJ17PvjbfLDXfc+7x7qu+O9wO+zDJ6HjqJQHtx7yW248D723XfH333u++9u71b7trufT0H2h7e+7tvb1954fdm7tdnffffHz7nrl97ptr3Wd3vnfc997u8SMPdlzNHdu22zsxdr0nW5pnu1Ob2untY3R4L20p6A2ZQ0vR6+8KaoFPEfXRp8T72VSj5vlXwAPvvnmfcPcB4d68d77qcng3r7sowe893rqDxNSzPnXERAmgEwmJowIZMg0A00CYJsgZDCATBiAmNBHojIGmjRqaaMHokxGKnho01NTzCNMjTRpMDIKNqegngKbKZoRoYJoGoIJhAABMGJqYmTAI0GmhiJgQNT0A1TTzRkqe01NqbSeminiYmgT2mpgmRqbCTRkNNGgyBoyGmNIMR6h6J6T1A0ZpBoNDRoNTSAAAAIAQaAAQaMmmRqegTA0ZJlPTTUnk8Joap4jUfqmn6jJ6miZ6ENJ6jPSmnqM1HpNqaMT9U9EaNqPQQekNGTI9NJ6h6j0gD1PUABqYJoQhNAanoJkaYTIEwp6nhNGnqYCMRPTQ0yNDQyo8E1N6R5U21NDUxG0jRtIDTRjUZDJgIABoBtQNMQZDQAAADQDT0ok0TEGkxJ6mNTaajSeNU2TamnqPIQ9E02kTyHqNNT2qaNDaCabKPUwmmmjTNQaYTamnqZomjJkMgyaZGhpozUGQ0aAGgNMQA0aGgAEiSEaATQTATARpgjTTRlMBoTJ6JijxBoqfhkJPCR5GkybAqfphNT0m1T9T2pqZop+qGT1GnpDR6TaQA9T1D0mg9T0jTaIeoAANDTQNGiP0UE1iVCXR0s7gtVcHWveVJlVd9tIIqRVIEaBw5vwiTQim+L4yP5JLqkJp6HuAFSjHVFo11iUylILkFDjbwxLp7D36Zis1q5ahVnEJ2LYDkWdE9tl2DvLWFCBUBVnLCVMAxIKee+qUHpacLuVs4Q3kZVkcYQF6tHOcnXk4ZxuXhJIcpAezKpt2Tpo9HH/6RIgMs4S7n7MBrbeXc61KSuO1Pn0T99QB4PlQBdaQD7Hj19KdABgSKJCivpYcjXtRQ9GPeYuY0lO0g/Ye1vPzqfkTohmL8H9b9wmnd9tQt18/y3jY06ML9zJr90YHQqCF7feXnO9edJRGhJJKZpW7cCMtolKBKyxAVasIFEQIk/P6V7NMCUoxWY7uMVg8/5YACBIA1NnVVRqVBmlC7StIeRXOUl6hxuWRCBiEihCJAOQgesNGOhQgHxeZwKSO4c9fcf2c5pN5TTEy7KEIlDCBDJuHEnmcJYJiwpsbKiry2NmZbbN8uKqqHJEqvxVTr9wtycZnCZBlItoeCj3jUjMyK08E3LcYMvRJyJjmhGcraInWRNyoRCIiItHVGSYmAaeWyERETGd4zwbyJbDIimbRRFTCW5GMlZ/Xvaz4zmR5SHIyM6WyhFVYzQzRU+wvH7czjiVon0gKz/SU24XoQEDBNNHpx7M5+/zAvZeVVVZ2LtRf3vu/29WoqaueogS+gwRDAsNNpNgEzEEzGNEMSA+kTPS3BNF6+lUmrPQxvKpmozLdWZt4DEi5HCubAbFCPvOqwkNJQYP4sbu7NfzVpEMK0qpk7q1uKpOg+/9SbInnBNNFxAvlSkmwhKzF9KQd1XaJNDBpA0ggSBAkgUARCIY0kQ7TQSdxopATDCaRJpCLU9Q4yBMYcAYjoCuMG0PIkqI6sTLENBsp7CVubSHDZs83Cws7D211Vbeoiyc7T2mBQUOfoZU9nQ8TcbnR0sN/un+73m932Vp5ebv6VcITh6K2JCnGAgofnCsEFpYToQvKZxX21AoO4Y7EI8Nhw/h2Copuo0YtMds53zdN38oYu5okEs69hcRhS52CLwYr/ajzGpygi8lCB8WF+S6WG54tBamRxGqGLhusxsD4GjKq8OI63W6taoxTNQJZrNNKgWOWxdYzqVGli2VdyyheDsKZKvS4oMsz0TiCGOSENtjKnsi0YnDC2O1oFyidz5VRxBe0wLEv3DmQyOWUPR0TXWe1tJAVEPPM6F6tvF1+w+cnsHl+2fnVDveIYgsNbq5EkPFZLrJMoF0EozXUzoOX9y1t6X1tWXXc9nvZdi+y6BUdM8CxbHRVWluKLNIlF7y2HD+593XCD+YYO9Arsl2uCY2YiTnV2kohWtGqjyUMAmKGyTeEiluC8ovRPykYvgP4iH2+p0Oh4PgP4DMzcPodCVranYUCJDUIZnpzUSmNQMaN+ah327STkJpJUGBymBSKctsP+Nt8LtIfD6mToqjgywjLDo4opDXz9NHOLgSNbzLvGsUNEx/R+Tkd34LLfwcR413vN+L8/v4Hc7fa7NzDv9m5+9tQ/3b/2/n/3/Fw4pOjS7KoHUgAt8choYxMgFoRMUgExZdC0qE1KYkEUcg4TRIhM4zkVrJzoIfNDkUnComrFEokhiapEYGKAcoduntC6/GbEx8TEVkLV7mVbyMm5cf2Zly5ctW8jKpZWUwzmaOJiSMGKM+/Yv55bBkhatHF9xIZaiX2E2cODLwYMGDBgwYMGDBHixsTJoUt/xOE4Lg8TE0ul4LT6bF1mLi4q484bhxPJbbT71n35dombldQBzG8/A4cmxHRPqfhiJNMQdV9IR1bhurKUml4nPEV/FCHZyBERCr7K03z6MbehE4xa28ouRSkxKl02IhhmZEF4Mbm1a3VgACdki95VI9xbKav2ydzQ22/DSsq4oua8qMTFcmYxCg05SJOYbhoXgNTNKZjYl9KbpfS9+WYc1aRNHvhyWDEUZMqGfsB5ITlgawocogfFOGAQhCEJD1RJCBAASKSeSEAchg9B0X4JiRRuDBtY13u8rpJSUjf3QoN4fiTnPy6TLG1mJYDAtYeYdDx3YzLvkFjHNMpPKLIcEc3i/CtCTz3In45FIgunhYdAun8Pm8SiyObP5YaPG5ubTc3w9tvN5k7Pdbyn0uYHI5m55lRKgDdmIdATOzk22mpmnp+PNTMxLtddpLJko1qzX3iyS19/r6muf6++2N9sQ9jg7HC5Wtyn9zn8q34vET9HR419flyqG54RIqO8MuLm6pywvCDDThZw4QYeNNNNNNOHHZ+G7u7xlvn7yuPt7Hd3pKTxjGMYxb7OMYx9pXcspi2KqXWAj6yfLYZ8Etoswb4YdBAh59DDbG4ifJYMQKMSpz9kOZqczdcxzmbyE7dwnayEN5CXwrSFawnr2C+CDBgwYNFBjQoULaQr2Ffc+Hfw8CHgw8HGIp6vOvHBwcUOVmat38zp7zHnfCy8vLy7pnmcbNznD9GDCKfA/wYIWDBgWwOYuD20fDhw4ZEi/f58re4tPepb+/+rkW+T6TRGiNEaJUJOJOJOJOJOJOJDJIWyTcXp43YfWjE3GoEbFGvSZOOfydrWVbM7j9A8awVsGC9YvXsE9JPSBKqiLBYZsewW3GDnD8+IedGIx9F98ceCDQh2xy4NXR2+LebrZYOkKBQJxMJRLblNbNbFsFm3NOlKlK7tX3333x8+CDsQ30UUT5znihhi77mPCzc3KiFzSRGmQ06Np3u7TRIFEvVJppDHaORVuFSeLqbyIBPhmTbncYcndxnkniC963e3p2zETJu0vOTwOTO2Q2ZU10uTyMBeESXN2+jj+2uo5oFQDNvXb3W/Y2MVXFkNUZ4hsFJCuhgu2DLIxQuuueMFo5qBWGSjJLZ8fTaTNUprIvTOvgpX30cSA6bwD2DIAiYgSJ0jTn18+lJGGQLC1RSxaiqIoOZQYBAHd8iRCcuZ3NTLCgGGUiw8I5ArVwlexWzlSoLkxMRi8nVlnUqEqZW8gYDcrzKovSwkjIEKAN7aPyqgCgGC06QtYdJbmxOK6nSN3ddEevwOdzudKYA3c2N0N7Q3tGDAv4gEsWWTgX3vAhu9uHDh0eLHgbutu9eZMaaggYwAZA2DXfaezs0BQFAb+83udOF0NUL0GHFWs7kFBfM4bcszT00DEQ1j5GAogqqqjdkzM1Ywu1Ha4nIPi83UHG7Pk9p2m9Q1uM7pacaZzNI5m2q1WGGKLLLCTKKJzI56wr5Fvd3W2W27xxxtJwDtwGg+/lPv7KCCDXikuQrr+zRN2dsjWrWHbVtxwyPVq0FEM75qweAzWaLNMVMVL74fD74fdFu3V3lgJEqAwwwgwwpHkEsSBycNlGUlrcbGxqUszfX1q1dVLy4jOxclRBeXIAGRUcXbKz+LFZoJ4bbbcyTT1AiEmniaClIRS0criXZbGstMWBCnG+ZllJrCihqZfk6k5UCaEKhraOKmLOoKoKdlYMQKJEpJwnCdSpkdPXVCoikJrCXgnFxbITJVUgSilwEFZoCbYgc5JvmbzIzVFKXohJRzRbqhfVHWxqfWrOAgPGECpnFDEJl93QGqohV5xXsksqVrLGhLFnUSpbJ1KtWakbMWqVeOurrdjApYFrVU7xs+bOHDhrAgQKKvdQIFe6dOn2yfvYG02mLgYFOIJfjhRTYbIYiKMY6jQNMEYBEEdGMNY2orKEkmAW1ujatDC22HaYkRK5r0w6LsstOy2ZxK7MO8UCqcqLvpBbVFn/aGPt94jq+bpMzw1JA4XXYIefAJjE2m03ftKTSBu9rP7c3P+TXNHE5C5cDE8/2uBe8e6x2PB5fGg43MekDuUPNpQA4wIjehPOJ+eXPhQDIzEb0VhCHxuRcIfn+xssEqwRRxPJzK98+hSgopEVIUuxXcG41BJjKc83Avpq6PUdQoKyaQll30CRnKYnMiJw4tSlKQeRCQkQtnZ7XxBeoKWHSFV2lfievIIXRFyqkKDAKci8/pDhL0hSlyoUFRVCRdIcNFHFo6TpQIKS8caeFQeH2tJhaIlabIdbokOA7FfmU4Tb1m9tjqfUvGkxRRh1RPCh1OCfV28qpEcqjVH3xaOOWPObycJaVVvlv1jFRqIqc/x/Xc3o+KPW9HC1XD8N+7wfK3k02oWT8Y0R9SpUzuYGaSE/mhZHDSyc0FBNy2OHCofenycPi0RpssZi9ojQRRSQzsU2h2ySSGDpTW0raZU7xcVFBEqHH16AAB+nqLq0cZOlTr08eve2WJtNn13XaVq1du3buqvYvFLyFVPB3irkmZvEbwsdWiS2wX4SKx3G/R5dbu8dTRSatiKO67W0ik+HXfZiIJrC1OBwceLghHhN0eL3Iu+eGnblSbpzrFRENOtlyg4VhZ9iqOw8+xYHXsvYlG6etnpGh5m07w96eUOaqaR+2hJOWplmUVxOIRZu2Dv4gCleFO7wgNUdKAkRFhqEk6moQ+tV5LrDd3pVjtCKhXTYZVbqXRAP8EgC9Uerwl91kAtHsyLskCGYwCsG3V1TsooVjLaDf7fJ/Xv/+et1v5df0/3dFEusLS5J4tZjmcus6v5dTndd/2IPa+Dr/Nmfch7nyd35Zf2H3teo/Oqmw2ux/r/y763z6MuRV10sjc5/bcPu+/8a7wdrqbVmNWNLZP2vkb7L+sGZz4csTGoY1h3ocIyR1BxxjU4w9mNsHz76fP0dWhfieHQ0JlB3gnT3eX9n5Xke35v6vq+xt8Hve9z6Xz78Y7jQa+YsrjdF+dFRVbzf7OrrMXk+LsU6aiqdlSqJ+XbTuJyuR6XK6tJQUVHSuKSlxIL1rBg1Vpu+36nX87t5UtSXTYmgAmga1FBP3bdsS0MF8ex7mG7s8zvg4yaQH8rH119m3wDRx/uV/4+n9TtTHLq7rUmS4Yy6mAgIGIFAwEC1e5kAlRiEWIG7du3SLUmO6x38W59/Pdx2h++JVUCvCs7GfhvGzu9vb3/a+vr6+vr6+vr6BFi7SghwWzajfPqq1q8h/7PxZVv8nZ9Nz2u9ZVnlOAEADGFaMABzq+X9/pC6fYDpd7s8n4v9UIAG5/N/VQrWsVaxfJtnLhDvKTwt5Ks2kvp6mp9Xx/5S3c2GQuez6Ac8PVAvtga2Acv3j0vMfERMx3yj/l3ewo+zpfwkE4nJZRKJR86aWYv45h+8xLPOp6VTOop+74Df1JZTOSyiUSiWWWBmUSsSyy/NqH/w9UfT+v1aZZTStyhH2/hzh52cToMTicTiecTuzrTf1xVh8vqTH/sH2L5SAUsUimnd1KgO/UqA47DNSp6NythJLH/3/qs2bNlyRnEmbP3Hrv7H3P7ZUnJmYtKc49eSGg0wyCxHoKGE5jEGMwwjVVOwwwwpM8n1WI/U+u+JRHLKDywEE43IWolEHq3sOt+xfWav3Mu5CrCZ9999+rxa0r7NJZ+vE+/a+ijDmQ5LSkmjYroZiFenlY9tms8badstWyyHxRBoYjP3MXFxUPYZVmKYkf7VrIuVmFJ05mcvIOnFQnFQd47bbbbbbbb95Okzp0mAUTpSTTTTSFGcnHjNPrGD1jssz2mIy8NygwwwwwwwwwxNoMEYNIlMMMMdlbt9ktR5zr3o4A0Nroej/p/qh68hf7UToz+0k7KOBiBf18vgb6GGHSiXz48/YcDazobq8byp55558mg4o0wgvfTVm50p559vRRQjVppzalS5arPh4VhKlSs+XbyNeJKm1XkwaVr1nzhlllBlmYyxfYYz2GMzW+9K0LN+Pi8DW4fqGk2dhsOav0GDWpsXHZZbQbbDbeGvbb4WT66V4yuwWEzf2FkeK42G0VG1Mp3PbfdgwsSVplPMzF44yXc4UI1ftUCSykPTQp0Wm9PRckYk30t5NN2c+bNZ1rz2HbS+TmUihE4IoNzu7C/GKLY5D6GoTFLHeewtmyYtXKuBl8l1111111/U5FNDvpaEARdqOMx3+JBHgvZbjZYuHZY/S3Mi6u0WLtF2rLGXa2bDDHJyUGMp1jLnwcKZPLwZLDi5XFVHLKSdNlPRRfdc9NNvLoZuaQYYYYYju8NttvDa3G4Rh3G9ucfX19aKKKLKbdbbbbbb0HHM/P2M7tCF9XqzQv7KzStK1Xjx7vIecUdO666uvSjuINxd00obVq1PZYYYymXHfxGWWWeE9dddXT5mTwF69VVcLLlFmw+8VVz9drqhN3ffdpnRjN5ym7vFuVAixYsWXlHCKKOPbRr2W3PHb4+Qc52InDwYCbOkhwo2cUJAn5pQTsfe+YkXsfL7PtPywEFcMBL7eFE7kd19PNHcd0DDa9AAAhEIZwVOlJEL/Dl87m89X1OpzFnn+f6un/Hre9yOv8PJ/Dsez2vU7/wyXf5w2pLEGNoSACDhjAWCWIMvmPQOEZjADRCBIMQBy5BX4Owm7Hq8b8vwe1U9/wR3Q6n5F/+Ppfo6nudNZ5+bL+t669owA3SBPcNLumB+Xmfm0Tf3Ldu3bnVFiAA0KN40SEot6yH1CA7HY+Vwn38rDmiiddrYOJct/SuH4/1SQPrb9k56sxgYZZVwRgN1qZ+X8Tzq9fjWLFir5/n14693lfVg3nztXdS8FeeoQAGeRgbebosM5SDa/SgSqNIWUwKlSpj4+PQku8qwLoNI9xrBYeT0NntomFVYs1mvr9Tg6Xd8nlVUb9o4QxYjEusxWmLl1f4ehl5z7+Fh42VF82WxZSy/ezLQiIjGkIAVSMaRnMzEZl47116+hztpxs/iv0TzEe+q9v33xwLXGpmLummKaZSiEJkMAnhgJMMBd39MtKyvzGCCXGAgKzSU3Dg3bFWrVeBvd7y+V3lPkNILTAw3/Uvb2X6deAvmVUzm2wLFonxGVGaAqYLkDAiE2yBzehPNAioQGqW1L7FB4iTKRYpFllq9bbh28iIn9Diq4rVyFJcPQR+UgHa+n9PjWqdZP6L+JEnfRy7mncuW5Wl0vpb0hmS1pQgSeUCUUVygdAo+t1U3ejE5qdpdc/Eq6tGaixSgnfWIu8jxfUvSpVSX/HL9XNeEIQRS7Re0KNrQ0DjTvX1bSM3031BAUNplBdkcCMz7hIBIVAl/V2FFvc7iJOVOZrW2elj6WbgAsLJkK/TWtNTJT0khMEul3fUdur6SI/NPaEhaOdFM5jEB6WbmJv8AxAeN5FMKc4zY4FQxAiHhJoLktX6lY+lE4zL0tjsXv7Hnv+5duoLWiDMhcM4W+alvWqwzhq/M8yVUbnz+/O9FhyBE02hgyxeslF7bQ0LFiWqiYoMFu+XMcwvfdO/wWx/mKlshXOb83y/G3Gq6sv2s/Usy8v5mDg+B1M3y8S/b8KztEMeVm+SkiGT5vm8lpxhxcFVXdeEigLDwjgaahmjBoWgIUjEFMWWTNAcjoWrfidlTPSijJIkb+JkQeFyP2Akjrdb40hHAaLfQ25COkxc5pLW8CD4vFjGu1JAeNx+MnbWdKREvSy+lbWGMASEMfo9FO9ocB9QUBQh3PhepSNDgG9VY5tuciFU4DSZWUVs3Ky7NixYr8jiW8ZRM/6KOK1er1c0qhtxCZw6aLZXuFMEByjuCgBgoZKEJUJHpeJ2Pm8yOp1ps+1cdJQOS9plmTFCYJcA3Os7rP5Hd0ws/UtvO6C/+Z9Hszv9z/fttx9zee9lKUtf3qKAqr3qxZbIdWIiIhfih/1DOCxZc6tKuKsp5239jzXs2qCWdSJLViuKKICwGIGBVgTLbSUzLKEWUVZYjwjQOETkKNlIAfcaOA0rwuNcO1EgPTJf6MB5HyW6PHiilRSQZV4QTbESjGMSWMi0U3gmULMFMJcwSa9IsyA1pdDHTRAP5WvgAYhwLYM4ubkFklgAcUvlSlHEXmkgNmieb8UzgXtW7j8G33rFQzePAhsCHapJVUqkUHft1pOK9Rbk7zZXeo/a97lzU/a9zo6WTVsNf613fIPbHrCtkfjlg6SpNETd9Uln640+xPaI3lzrpf56bl9mRBQyHPTuOsstcoYLpeXeXslIFp3d30KlkxxAMQfH6++f38g3lczuu8QN6S569NfB733Of+n2rt086xeYLOq1CYj5F7pXobeXVckeJ1vZ/e3PA5O0V95Wb7+N8JqF4FWzAiIyNCN7ZQABklYx3ADNtPxQRkBQdX+92BQKyEZwUokmr5/hJK73PjSpFQh/qkq+d4OX7t5V4Sdb9kqzMo2fNN/B5WnjVXV8Z4T/C0PpGowBr4CEzPPlHbLhIjUEmRQaJDUYfvofGQyP4ZMaooLSskAA4Wq8b7vY8TuavffzlcxIrntCn9gvJe+uflH+R5t091Ukak1E33Xly1AscsnWnfyfwjC5KvROr/ORLUrlp0z3dblPJ8yjwMP+VjzNkvc7ib2sQ5ZUkKhVa325o6sfXs831+h67Q8IjYZRe+GjXIkUJz+OQx4d2KYasL6UIqCPdBkI4BwEZog2ozhKE7ZjvxATgmryDGYzvOBB7ur+b1KbCtq2dZw2G05MSUweJh5W42MTW49etgWvvf5f9lFviVfQRIuAGN0GBiCiXSgR4Xne0/2Yv9D4JPJ+T+3fJn214iOqgFHjIGACzRiAA5ohiwmhL2PO1aePX+tocEisslcBWlSqqrqovI8b8zJ9ZfqXasxUtEFAqA2201iqe/V9oRn438hfZkwHlU3Kb3lPvsywX4hZdtsmfcRqJAPZ9HLtxtYJU8KN3Tmgx9HTQbp719Ya/cnEoYBD5dw4Z6n6f3Xxkr6Igz1ur7HuIsEOYQaFK3RakVacmwNjhwqDEVTTl/+JqpAQ3vyQ3jX6aE3LdxEGuoxxWms/KD6GxQXQxyycXZuTKJiTYoZiTdM7ZvjqcMirtQu5Rxq8f5HPun8Qvk1gfV/21HeREqCkpLNSX+eHyNVAXSGbgarJWCkJSEMjbdhffZ6w+OuN6XARtFExVdGoy4oFwLu66+EjCc5KhA6ErKqkSlqzHTT9xLsvw+HuODd7Cq9rZDpfL8/0eBhdi+GzIiEQwABjEIQKECXsFGLQ+dUurnB7S41JxilPCz+JcPI6CjCkmvyeGobm6yHDVFAAhCtFrNGhvj2tyKUBQsaHJkIyxOVJFwauEGmkPtfY+5Q1eofjS3Tf58E0fXsGOsYhHb+IcggeRrnAPf6Z1TRTjExjcdnYOLBZSoMX7dbufQ+vn/r7kM9HzaDd/X9H1UuLls5Zz/f7L79O3hpt6OLbUMC9vvo8cjROk7mPj4DVrXUxRTux5QbZ5Y2Tt8lyrMgQwwgcWU4WW6AizKEUPyNcjoGFjAQxi9V6TWHidi1ylynynOv63ubKNfoqermYSsx63j1tAvVLUTz73vOd5nQz5X+f95gXAGBXU5wAv0owC+hQBkh44bL9WjsCWgUET0hahIcf8COYQfFzedLJDikJPrunXn58e78vzvPbz6MAEASgvEGKOj2EjqGM9JgsP/yZMa7dMKuZUXnUs+xD9p77byztPO8y76cfJdfx5MmTkyADajkBss7F1npfUt0hWgWiL/O2SGVBZxqk3EdJJCgSjkl6w9VHw6Yr0gB+y+YfeWHmx4KdNLrc3YC75ffu+M7uHcTaSm2gWfou7mhc17dtj7WXpej1b/Xi0tLUwXdjYZFhaZPE+1jxJ/d5bdutueIXgzOAS5Dn1mVst5Ufl/hvPS4+ZsJbXoeMgFrxAoRx+14Hn/J7PAq8hGzFbEJRzhDazhiWdsKnvvQxPrcn1nwaRe2IH6Pw8Bi9oye+K+nxR8X3qNRqlGC1aWfIVk3+hqo3NpxS0xAgQIEYA6HEMuPF5VdJOgVFNWS0ejdQSub9yQgVIIhivUJKqiQETa2k579U7jz9HAeg03lfE7nueR85U3SXiWoi5FZjATvT6s0/IU0+AacThrOHmnjttk1mb2x8YREVt90aSuzUdl4m9eRQquDnWsZhDTGmwWYxQ5wvG5StSPNs+3zN17Xe7Gvs+Tybtv3Mi9Pj4QYc/n6nP3eMB1PhSqBcTe9h9t6psz7QojQiwVTAHDLEIe5UH2N64gLBZCQ3KxqqNI+KUs4w84HK+SKWP7RXx0PJn/KPG2VA5L6bxCHBjUPZRp7l5ROGtE/tfbtZr4IcRB60ktfGME0My/5n43ceNI0a8IGIiaerBitJtJVz+MTSm+n30xzdXBVOj4edUWwRE7M2uTzTJMRPrvEztaQpK6QmO7F9BtyYoRKG/rJ0RbEjlmFQMVJGEUjFKwU4aR+vKhjost20EGUwKbNW6aaRZVYE6QSfUvzv4HX4K0fTjzlIe9D1AmbdRk9CqWTUvnXul0ZOXjLcRuGR1z51QpMW6KoLeX+e33BwP/fj/9/jjdTkWNXr8zn8wgUZkQJXe/ShI2UiH5fefiYG5+pp4PwfE1fG6nW+hyntuRGKQDnERRAAjKQYX68KRlaTg0ZAIbEDJuW0hS0LhyBIJBIMsI1GbByE4hR2IKaL6j2+045OOYT7RqVXUbUGBd8U/J91xE/CLP3PCjvEmSYWHEhg0SgTQw79lcwTLpW181awQHijnicnjdLTlFv1PPr3ErQ0agVsF8mnpz6ZFuDn6PAKuBZ65P9UZwYOBgQ3xoWc1cWyUSmhafhq/qf/fE/HpKrJ9LjylNB3hKAfrwpudvZDZLsKjDcxVZPKIiGY0LaYpcqTpKk+804n4VU4GFvVSeeSE1dpDQAIVcKHFx3nS+XfYGSrJmvrbb2knR+9qtKTbewimCirK6hXF02Mzw1IENZ4ks2dt2vadx2FG10m76bWd3hW+kEkGdGJZ0RXSJiPdbLz2n0+pvNNytdX9mMWy5oVumNU9I4mcCYcmrnZtcFh9HkbLK7HhMXL8PY2FiLhVaWDpyjbHv8TR8i842eEdC6hDnZa6vsGtNZ1PO7+nfSEc/Kbm5+0Nxas5VOU3KKB8mFssgsIHPqj9S3LJYb/Kyo+cMIVKTuSjy8ZC22D+gOhwU64+oVAQ1gDIAVptW+I1dzxtG/SZZoFiYuY0mtqoIuW1myAShiX2qjWrsavjVQsGRccOSxUqx0bTOTVXVzU+P626kuDtNXRMpbKXjX0qPHg2L1tyuQ0lomIBRhE19yMotHUyuWiIkRZTBoZYDE2EmOQ5if5wF7PlX2BWTZgQ4QoZfRAgk0UICwm7CLw3FK96Fkh7bIQIgGLQKDQAaUYAlSDfS506AzDAMdrbWjennrlpbbia4Zg1wjlFMoQmUJZjIQ1+4x1HGYy07TpUzJiz0gpwZhRRHY6XY81LR3WqhDscKf3j18nUYiUE8iEehOKhizuIMdYAZgLlLhM4uFgkWBMRopSQ2lb409XpPWWPR+Fh2bFYVqzbkwF1ImDgXNikOxIAOUAexMarF02JOTmf2ZayETxEhImttq7Y+NyD+HLc1fb7Uf+mqwQ1M0QF0hpGSIaEsXuWsCsIkDLktAZDBm5Rdby5vawsVVN2eRlSFS1uRw0QyxKCVYtJCmYiTvC9xeqV8zdGBa0VZ3oGOd5DPbpoJGM+CccwOLxgYXzGFrQFQXAiwQqpPIKkY10j0y7VYPKYdlGi5SgL7quDATxmPheP3yPv/O+RqP19fuMOxscSy5LupmszNkLVXf5xUU6naOet1tg1Hqj6+5GBPGIABEDMGAgGJoSkRHWDaECJiQp9HQqKIaQht0NqBqicompsQ5iEIkwx+CWIWzaxLq1JUafUoGgQ220tnprW2mja8Xka6vGnSEjNOq08vUSmarLXN8fxculpVzkV7+qH3xmE8i4dtTP0WvL3gr4liavuJWQkhWEgniDZJl86t9YPfc3r01kq59Co9atSKKyySgZWmTL7aRcdfQ0fP8r3vv+UO4F0OEEiRIkSJEjrBbV/ds3IIXuwSePE0EuEyTyZpNtjAYLg8Y5JHkKKckGMcA2QyAE0IGeGAYu2W9nb2OHzIvqF83rc7cpMbc1dJuVd1uVk/jJ8iXP7o1Hf+Uw4GbExC+z6nAPIWjOJw6CYA5aCEElNyRIGCLmgftIokjGMXqOIrcuRvg4SXL3zGdHBCu8A2T5Ai2BKkjqXqCBGlBOsrKyicpnlWeSmycnI3vpraapSoj5yKmSJk0VOnTpuynTwZ/zvxXK7EySlWIAughQ8HQLq/qMG2085EmRGCLnmZ5nqFbvxXTYPyqSKewZe+GyH8RyxMV6S4Aig7e0xYHfABIVNz9DFlWVR0MApmNfr7eDoFhYNAe7XqFsWKKnGcIVEiGRd4acoAubdvcEXFvcXFxb3D642dhdeHyrx60sblU2mJM6c2hlSmWDMomWSV4fDhJOy2MdVTZdHyMukVOA/gJvQ5NVKbJ5I5I65+QYOxUb2aTFmsHzfbAdqn6WubjxNg0MSurI226bhHZ9yW57Ic7YZ+JV51ycMsrBk8HgjAw46gfTqFhaA0ND5qM53knksnshVWtE/OHbmqRNzt+Hj6m7pptxd3sI/QSsMii0E0EEZV3U3p3GrhZR2cN24fa9/393b0qmPu1XvoY2m1IYQNKiQY3F8nndnb5upp6ekxzN/f8t9kkAmzZhxOow7J3B9V37zzkUUipyAqERwAc+iJ7q5c9NWBllUVhA9I1Q4cG2fBLg8G3y6uh0FTxJaOjwkAtkMYpEgwld2avL8/T3tKDcMDgsQU1q6EXBpJDx+bxvJ7E1O2ISKRCRDgChjryjqbM9Qb46taPmo1DGPfv12FVF8IRioT3ieh3qAAw51FG6iAMsXTYNvyCJDSq2mMHL5WLQUmRjo8pDJiMLZNzR3NE25o7l/cwbmfoci5IhRIE9kTbETFiiWWXM4Kiiiik9NBdy6EpUNAtg8g7mdtvO7SfF9qXsiXGv4lWWWWZDaP4GFq4rdTjlo6mi+iJyMcFTlY8IUBQVDEEIDsuXuuzthhEiGMkDSZdmzJuc8wb87+TdfQdoz4U7xWYfZpa592dSsjlqanhgdnAcC03BQzNEQ1gRPSlf8OEGgYmPkZBoEHCN9wMTWxLWCQm02mwCLTDrbPL5iWbfqx9q+0zuo+fz1ex4mmt2Jumt1vFW7EV/sagJ9YoE3BKCZSxwYxaFCYA0DAPhKksmR1kMRwBiP2JBDlygcufFOXl5eEhF3GfFi7jcYkCAngaPN7jubnCwuI5vI2ebydZ6bCUXSWx0Oi2Ou2lcpLjoXbBO7lKCymm2xABsqrnN1MPSS1RP0PJenpKtSpS7ybtiksgaVu5Lotilg2km1/yuQEmvu91+Z1TEwvxv4s8eGBKf631j7NMUBIz6GbyVE0VE2wbmzPk/CfdygJdhfAwIxnG5FYMABkLsHvSFvX7rjniXlleRJxDEuL28vR3dzblxL85BkNouuWEcSTJLDu2QkiYxYbislSSSSSpq8Sk3dM0QA0GYMgCBkDAK6umSfzlkMpZXKLC9CaRa1B0n2t4W73dtbW1tJbZH4+Xh4LO7u3t2InLevXr1AWLFKlKWkyZM7qUB3ZYEHHOusClMAYobe9a2XM7Da5HMx3EoFDhio+ZXto23C90o25bn3ftlWVV5DgRUOxPNSC28RyoLTOtegdT4085QEBtU5ZimMcc8DJlfK5WrxLzdvZ2CywTZz/Ozc5DnWrVk70MKzEATTduSSBHZfXXTZGxwkDlFIlMmUmykyxMmhAFMRAqqqqoNBxYO6rOgugYpqLpDoVkgbS29PT+T8T4nmYjEWK9cm9x7vM3lRWCMtuatf5oRNsyFBGOCFN6D6e3MxZsLWF10/t9OPpd+2tOwgV8ZlB9Fqk/mEA5KnLW3XVI1Fc98AghgnbgZeYINmIkgCDhA6jroYFYM1XrVfBDAYCiiiilpaRZ86u27bMTjuuXcRjG2O3Zz91NTW5ajx3q8ba4vt7169An2H/vc6SNcpMdt9DnolqFoNUDnOfjtKqKUsk0l+YFQdQaZ+EUWC+LzOZzMOIrhwtu8t1bT33qD4cguRyvUlICYUMrCfq1jkbPr7VfbDdwHoW66FhoQkR9haOjzlQIBq3yYRUNulb9Hy8VX7OnB5jjKAsNsFg6uKSq8ZihUV63VnvUmV5SPylcqZL17HF9HYaoCHxN/CKGLQ5ddtEcgvc95xa/3fZV1AFiN8Gwh6dU4vyA1jbPkQs64izo5E1PSXymLRTk1wfCv+G2r83NoM630tJpub6FBjUltzcur8zpNpyxteu8oHNM+o66ZtCiwCuGhOOiaurMMtTl65uLijR2bPdGI6PyLFlg8Wqs7yqtI+Qu1lfJLpEk4AGCFAAYIo+ycqUC5ChSsbKTeJUsm7wHkZVj2i1o0lrOExXy8m0ld5a6z3UfZubn22bwM6HB60aDGvo3Jv42Bw40GpnZyZp6avcVwA3dVhlRUtm0W/QnDauORlIsreeGsuuiHIqGaGAw7Rd76a8GPwer0OrjVUA94AK5+Lvd3xZWsY3mIZCCBd7lwR5NuWUkYw1VijO1UPSS1iRX0/WOwDT6I1BqFb4GmkFzR4ndA5VCpxDpsilpHCLIUhkJJaeKQTsn3LDiRWLFxSIp+JHRAb7SJETRIhES/IiRCGuWREiERIlLEURDOoA8vLy8uREXnHWDtrKW2GFe6JfklADOlOOVAF1nGOvgk4XxFlgXTY4t9LR1bJ73N5lXY2KPHqwH8eZrmIcjqZw+JG56g0GOHnc7f1FOaThDgc7hIbvoHw+TGrtcNMBgEm5jdSLk72HorGAe+/qvvuuHNtKOjVhSGRk/fuJeLyPTQtm7Xk/is42Zj2A26MLMagQ+nHv9pXr+r0ukV9X+6NDhFdLHrP3MQcYwb1R3kP8+oUjPgdpLrztQkF9CGUkGekuQV77rIs3AHFw8U21Z9+ARJ3XaIuuUhjjhRZ70PPce5n/fMUBYTkd/h+GD+Lvh9I9AHTn+EZiyjO5kamNLxRnbU3z3rem3lG+Y8lKd4lk9/Vod19ti7323DffsvDlwTKa87Mwm82KxeZ8zFuYssoTV8zNSsfXrPe17L4niZHf0PHd7KlCptUdoWp7jM7CC5OEOiRilhXArQXB/WK11RfjT+sG//FKo2c4/SVW6Sq3IM/30u9wpBhH139aZkvoFQ+j88o8xwpZ19E4GD+4862SKFX/0t+Px/ZlihytzHCP1DuZpm3CtAAKtmnrwRzscfQb2vjl9hTZJLpwAu1j2J2mMhvjHm+dKO2tS2fqIpg6rva2J4nQ54ypwvfe4m8LtW1OotIGF/jUOuukdNd42SaP63zPICbYNfnz7ylJ26WwtWebYvWCzDXJGqvNzq2guWDcdbqaDhxtbeqyV+vuA1/DjRt/t41W62m98PxY2ptc7Ob72NbcLq+/SGZT0sejg8D8RA/gEvah1VrOiZLxkugVBB0iYinZVLqlJtusrOvXFWg2AcgNHb6fKWR7JQ6yet2eDg4XyrDkBERgy9ut7jIcPZyK7rrXs6icZ74lGtu13JVfIwTIFIAwpvRQ3pwUx5e/eTF+qt1p1aA5RRqltEU6850qe5VsQoAP0fIWrwuIkM8r4Y009QpFyzaBZ9m0jKHahO3k45QksVZcx7hzhuqcI/QSRzjcX2R76diKfQDia7RM8mQOvpHSZqImC83zHWO47G364SSehPoo54MFMKOqzZGjXAOmn5+EoaSTFdChO5yFCpYUvCo6CFCpIUIIUKFCrrC1dwIEKFChQoU9PQoUKyhQsHp0zkibb06EZhAp6DP1FbThtT3pVtMjhoX0ALcOb6dYcFsG3xtTnIzR247FRyOBgVyIczDTItr4X3Vnx56co5fQxrIWwgsZ8a8Wvzzc/mnqKmXnk3o7vm41JfCg3ykrHJjsIcngvYcISqwKLdryPKoxMdLt8jtVflAcpa1cLJXADT87z0Yhv76qFU0zONc6TThy+X0NA9jzN9mQz03mpj9nbYLK3t7f0PQUqdthLJSQrRibJ6B1DhTUk3Q0sl5SGiYSXlvHDFmyJPzc4qM6ubB8w9Dpob6Z6+25bbMkQzo3oz6pSjIFfyFSSABUjEM+xJF6NUXgAZLhVuq50WDkebRM7K8S5pKg6dn0qcEI1SDc914R9o/Xd2IySQ+rvFQehZHSR+mwYgigdVwRvwmEUsP4fD0K/TQRQvFGV7bJ9pfxX2rcRz1N/EIBnLr8Aq7JijiF1S8tTeXYgqnOc/PSWHBHBpa2t3vABsG9h1VmNdBfMHDJxvqcGxC7MCs24HKmtIAramGXXbDsPTj7A3cNWATlGnkpdVRDMToC/Cj7f8SPQz1AVRWSYoOW5+ec7pHqCWKh1IGuPKITVV65HZB9ovkbr5a9n/X232/6Pu2Q9m4I/Ws/cqxQIc7peXQIk6OV9zWwg6eFtbyhiB0nF1r11Tf0E+RfV9yvH19fcj68WB3VVdYqbx4hXNR3+f+78zTSHL51g9Uslyww66vc3dEGtzddvPdAR3Oj4DwnRe+1moC8UgUa6PunM0M1uW+eNJfq1q1iuYyk5cvmdUzZ/F1/+mNs1caxWJXQ3dkNcxrjV4UwQeYHrB+iAfLCajIyPcSUs392YUvK+u/FyPiGdw7GHSX73rvE/ymDtEmDgsKkAuDg8k/huefay87asft7uYAJlt3BVMB5HVu3ADkAJ/HMHeeQTYgMIKAPcAl6QaBgX8E1AXWAgx+InyvIgfS8uPqAMcsECRGRw28R+B7fe03ARACVDn8OKd0MJRklTfIAWaFRavj7R9VsVsVqxS5btzUiXPeDtsetjRdvEndQNTW1puNPcTiWsawr73SqKPxAjYF5G6salB2AW/F4Ya03XBaDwqqpCopEJ4DtQVPnKwQU/bOdc9WiCmYuiDYfCAYDBRNIEbYF6EAkdQOP0QQo84LTAEiT8wsG6IDl/NaELxkgZkHC/AWcESYIwwkjEv0QYpqpO7k08BOdG+yIKRFLYD6+gnT0a31WKOOnSyDUpY2E2TJXie8MBONsOcNBYA8/Ji4wCPvqc4DeU8eLZ8ybu2HIBB7Jx5ivQAnYx5SIm0+jHu0edG66xM7tzbtTxarrO4AgW1IKePj8NHSJY60/MY0UP5MW67BZXnOSNlxlhSNTFEAdEAgABrA9eRWggMVThxA0ex36vu8rK3tUBq6+PlCAbfv01dKpr5lu3b4fvcXN3FYgMAI8vHNMwg90yKPSw3SGxEDxXPpQZI1uW8tPYzgM0U6jmtMYdgKqzCapJdxyUe8KjXzsCoV2V4TLtCCla1eQaqm3FdVD94rNBk01cgMwGGaE02rMBMZpNSrEZeRB7EOjj+T9On91X6v+Md5GeEeQMehPgpFI4MNe0yhah7FPhbKPXquDr0c2Ym8547b+CLlXgN4eaKfocF5KAUcg5wzMe0nWWzs8HaWDgALKx7bkYBWg6ZLKUE68whqBpoNZZyfP6Uls4CNtLaT5ZJUwn2lpaWlpaWlpX+johot9HR0dHRpnkHR0dHR0dPRCHC0ej5XlNO+3ogAKanen6qGFpiXQPcWHBC+GhCwc8zY/WvbhUbjaq+Kngy+t3E/c0/dCrMcbyQ+1dVnyLfe+R2QAs9SU/DAR7wBBZB4W/WudDm83mpVEUUbcz02lr2qsGSqYQvwS2cJJjgHMvzx5xKsm7RvrppiKunEzojFEgvNk4ABRyGRwzUwASA79sWA5sCyyAWgFX3nEaNiu9rzwF/gDtxZf8RKBXvr7mZ0WJck+fXS6BALJeBhPAPkbvSBEnwijS0tIUdLpdv1a/x/NPjW3QHFzImmwWNh4/bKLxeA6TRMgDQ7c9F1cb79GrYYB2AjsM2qgIlExaJoxVj83oW83EgxFtBesy0l3Tu+4jzJGG5RQS79YwvNCAYdhnAwxRDh8TEDDgETkJwRW7tPdnjkKtAde7dsJMhLNE3tmSg/lZ+YNCdAI4UskQCXkYgVWZvfGkeLja6duoyypni74+FDHUpwFSPivWmtSc9ZZZttgzZ8SD754Z5NMRuNOJEQ6i0tdTMqN8jDdMizJdVych2JszXZvmrrCiUKyHq5Z2twddnPPQu1JciOCK4kimUQi6kapksJmN6/Sv258vxcCpgX+KBfuMk8RrN7ReZJI0J98wtb8avm+BDlqdwXf2Amrm4cd2BZB/Z6HZ/0Xik2DTiqhgk+KfpkZTDiTUcZFk5wEKl/Rd4yhg8W/yOINRl3K91UleHwLWVNLvMAAB8ZtEiFko7CKKXxlUF0U8mRJycnJqZOTo3L/oloOsQuYUlONH+gWNmAAKp2FRCErTbjPzbajyF+2G0nw27V3TxyQNqQMEszdY2Li4sgssjs8gYDM2T2dpJA6lilO4zolaPXcw7KoC7wXCguB4zmpI2M3Fl0gAM4DQAOA4dL+7t+ZiPpRU7xgNc8mYuDHMX6mdqIyZd69kXpED4dAOlgV2L/YFKVMKlC8NVSzZXWNkTVOCAl8BoBsB1HyMg9NpQ4D4AgHbAZdFPHhfUqAdmnfBXWrKodvdDphbCsGprcvWszgkfFBgkeOEB1QGAwgICAGB2AkHch2AoAVvP/CpCkKQYeIHECAJBMDCsFcJAThOEBADCgKAmCQDCYJwnCYIBhQE4QEAwgIBhIKAYBAQBWAU4SC9C+06QQhOfo1piJAh5UvPTHd5WU5n5WU66W0MzM0Dvp5CXoJzPRlZVQvsywYuupQu/sMVd1vbe8dumAAFni63TynIbfElaNZgZTB0MbOKE2ybv+/9R2PF1cOpdDksDhBY34WYC7Ab3ZydquujpbjR0NHHNwOsXI8nUO9lgQAZ2WKVmEa0eGdL2qqZ9MAT15/sGUh0GVAHqRa8sirpPUPptttDalPNSqTeTEw3Waj64dTLzN5xivgAG2DBHQDV05ApAwOODAxgOuZxMF26y7flioDi0thHI8swFSZUqVBU53ErX65mjzgH8IFEItQscs31Y35KMRIehY6+Fq29+CRv7kuNv6ltl7O4lZ8llREx5t96sj2uPytb53z/o/wbwtcLPsEmO9ZDsBydf5OxQHaD42zi80NqzegyVXGtn54GTYRCaYFZgjmjOUQx8cY+Pj1sfpe5ZYBoDulqlESBCBI2rv8dPGKtGC4mt2KtPP27HT5QbFWx29sFVBWwYDAYDBgiATBKcGASAYIkDAYSCAFIGDBgwYBIGAHa1Or4l+XvIg5VfARJi0GLOAkGaZpCmQBDCJy7Gm83l7W3Me7TA2yrar5V7RO3R11bcX1zwd7ROiq0PTcm2ykwPtahqGnp6XH+vkb7fWMm8WgO8mXXZ9ANn9WrxcWmgKeXRX7cNINIBb4CcCAYMGEg1gnCcOuHhB+pUs6OLcDpXKN5H66QnVba7xgE33/aaPNs2HllSxSmk9z4Jev3kjzHyu7SiXLjlRUzopNmMykZ94ty5cA+emv8k4G8uHzyUI15g9KXInNETQzxnjY1c7L2mchBRnQMkUBHDZGLMzXqx401JgyhsQEVw8Gdlr7kAIB4BbycXgnMumQIEkRcyA2AJsZNCbBjENpNjTGwAbQxsGAxb/Az3QrxE4yWmQ+6r8/7881Sx+Ro00i8p5e1HZaV5w900/ARoHngLvBXuuXfbfoYwTeYBEDtIEQF2/NBAipjrDuUFs/J428pUnhhybntTE7EpYdZpqu2syInDMak/oTSvwA1ICAA0QK4FXwOpIKvr3+UeWHR3lmyAYYeIF2ZpF5pHUmMBZ8LBvIthnzaXWz+Ivzd5crplfClJCz3um72OXWi+p3dbdawRllT6N7n0qichotxhIwo396sMdV5mbRWSbYLt82V3/463Qi+e2ssClCBSEAkzueiIAgvynIc64E6dGqt5Ib8aLliuqsoxXCLzOLssCemX0a2dWznKfY6fgTKedQ0l8OEYQMLBv3RlTSdSIjRl0/B2bGPxsutWElTtZkex1oooEBFOu82c1RnfIHyTgwUHgNMh6hmpyDvWDsHN5erSaN6XjVAECI0+WaItRXds1eKABLnAGAxCLBaDQhgIQ8h4RIX/KNTcRrbHxZVvdXN0/PHN7sPODro8sr4pI0nO2DkxCRohLMuzc4W7bGRSVXeEIa1Zyyvrrh+AYBN+cC3BtrkNJ4qB0ARwZ2FCn7zPtdTzuV1eU4ruSEMsXhvOPraEXt52faXX7NyJwLuXJTF6A5JTp06eMMbgeFUVbLBIH5SFLSxjeSYyEMvRWcHULSNplr9rhKtUBLsgBPGUAQZJ7DY7Gd+EpaBrMHkkRkO6PuPBnyQ2i8C6ywD0AWe4TaKAiktAaaa3raUlBtsviLPnRnQMUhGWFK7n6i3qyoWFLBNjxzvjHpVW3tjG3x0BRCDAS0yRAkAMXKcB0PCKzCxAHPADug8gEu5Dxw7kNsLVufXtBAFkybQHXzOnwPaOiHfH4Gpf6uIHcnrn4CD8lNJ/NHtBqCK58+uECq0xC3bF76+QIsCGIlURZB0iJKwvxCrxKYiuRMWUrZH6AipOqA4WTt7dEtLNx+JxeLmbfOa81GCW1tXzbSWnMc6Fu7F0NZ1dRotQV9vyu33DWuvrarXSHmwvZvwe6we3nxliVJVYE3oEQZyPm2ZUeN6OmehwLN1aBUN4lyOBvAmSZOYvwGnaWqxcq8EQlgnnP+Ez7H4bqozuCoL68sccReukwO8AGU9lyIlIi9xFWRbn2zw80ZAKE45VGTGs2OdsNHRTelzTL8ks0H3wB8LR4VYIzxKAxrsIX6+l3eh6vV2K98+XcVjZ2blzc3NxtZQV1jDemnAPpTKQVR3a9QQI9JwEQGQYhFiZU/VSBCkRWDdC0tUvwzRHHC+FzxF94AF5tzHPi1m4Bj1tfXha48fi5Tpl4MTcTi8Lhdl1L7gLiGWWq85QyRfbJ25k7MyVCVxKmwlugyBKUyV0RzcLQ//dx08e0I9QN0tiy083REWslrY2NjYzd337ryvvzhFqRpxwWW8co3oVA1wlAXgiYXIEXu/uZIVjWLnQJg9vZz2YHVLlsNntucqmB3YXRdI0EsANIPOBo70PJRnMNVYslWuqcJg8IMFLIL9CqT4l0iIIEHJJZC6CDnhNSBs49Sve1W88ZuJTXjlF3yph38mkJACCiBAorIWQhTdF8M4jRZDjUoXj5BrVRpljn6/PxsjcVL6mTzWP5VfPMTDMa/Fu55ZBxsbe6tVdJNfbSxQqcfUvm5YAdj26NO8UgM94OnvrREFBwZLydEx9VdY9k0peqgp+Fu1+StSVAISKghFUYtTp3ErV1O3CvbNUKNAT3fdJ95Pib58eYPH+NK1lSah3s5O21cdxsONCmPf97Dzs+3vkky/iYHAf0LHgKZUeza3+4CvkL/IDEmeFpZ5k2cmR0djQtiiDR2YJSO4LQ8QWZhGYRLeQDwEW/F9b5XLEd6I8TSs+1gcWdTWsTF1N3oT9UEl9f+BBRzLOPk/CLbLfjahMXoCQFTb1F3kuaI87m6KTESPF7Nvm7HPOYE6DdhliKdu740t5ZAYMQy0FuuHTEaGeInKgHECpjGmpU5HQmqFNra2t+DKav6wyPNtMuvHvYZ0Shw0OG2tq5McgRPsj7L9L2O/9PysW3WqkUuG2i/mbiWpgatE5mhJm0w0xELSKTcnnBAgCCt4e3PNYSX0n2Nc/QO+Vp0otOjRJh/TL3U5Z7KBpJxSol/wQ4NmFA1k5JvZsgR3Qla7YR8anc8TGtE61KusAfFK4aPC+TZEYYl6fQ0/T9bAL4vS4yzEV0sZFhh9qYyFnk0QVLMtWiAdBBuRGHj1rAjECfCCQek/lb75krzEEXv4W/+YA0DN24YCEJ8/ROGsj9qx3fl5Kb5sbMXasUoBAJyYtztygxhqXyrNMAaIMDEUlAmHFzgxoJwiYMYRJImoWTJlPcSoEVooNzMq9vfU6NkC0OuNVnBuLGNuuTlVRLl4igKwvpN+P6PvNdrf4BGLu7uInGLu5osWaLhTRWdzSLRd3NleLO7u7u7uDWKtFwpssXeLxZnd4urs8Xd3d3d3d3WLu7u7Rd4u8XZ39954AzQZVjZ9x5+31ecIIzN0soRlrDmO4siXDqPW9LIw2JG8VcrYIFIpyA2ODwdcNIMsNTk2e6ErAWS1NnBhZrTyQO2lt7fe5mpjLD0K+n9PscfHx9Bgaaxbq1aje7vWh3RF5qKatR1lFbryizeulImO2IiPHUR+KRKpJb+yaTrgDXiONIe77LArA1MhKXmODhcED++hoAZNcX7QdHTOm7E3R1NVdV2UGYDEk0xjTbaG0Ng2NMBjSQ2gGjjbte70vxul5vu/B71WsV+3+rikvM3u+c2qWD6WZy9TG6DvUsbQCwB87UpojUhy9RvDBg4YMzDhx/Lffbdy/ew/eSzFIDlcjj9+8TEXUEdLXlZnAgKAmhSDoHxDhBuUv3SKeLwQFBOGA5crLgXTjSTEFEC8tPEq9YzbuLdWKsQoVNwgAeaEOBGSVGNgE87377n8esHzMYRkpZKJgyBHVDDQsUySpG5zQZAihGxMEIMK85dhLzWZdSm35/p4/E4lSoWvhbq9CfZ7fyGQB5q3FZrtWoaTTci7dn3bt27j1rubVfKvXZvHQIiUBEPXxdfYm2NT/45YlTK39WfrM9gJgjphZUhTwcCdOv1Ho/8zfz5zCb4Ar6dgLYMRQBrX4XVxnls1MbjbHAbzd30J5UYWGY2Z8z4f1fZ73L2utvyzyfqWLLZdeC7j6nFM4SyhGgF94yFod6GtUA2gwTDOgISGoq7LWvEuHu5zh9nYy8/V1++Xrb2frHexnKIEvH79rf9AxL7hDF69P0dLNvXsvUWrPhovsGgV7W845ZOAYaVFHUzx6wWmlGeLceFyDq82j9DmfKVMnOjh6dA3wE4ujaPTpL+yQfnFb4JloqXx+4+ceMnAwOrSQ9BGQnMHCbduM+ROs6mlxKPgWWGAHrA8DQxU4lAExDWiejfW5yxuL0G2L6LcabTVbSbaAlZr+D5/zI8uqsbF8lf4zzy3etrALK+R8XpttqGhI2/aQ+9mW+im2qZv7hLZeYojPfuAMplBS5EhJgOfBt9e27+xpOAEFrMu5Jv3++6afylodP0hpyG3c17y/cZ174GCm5bdd9TvXw+i/mPicZrLCnoH+4wGGHLei1kONMBcLrI4HDhwIesNZ0m04UrRs5ZUKqqcF1n4cNPBp7NrUd5bwPHkDSebOt8bU0tJ/g2hatC1kV15rh+uwBj7kdnGOviI382m6nOc9pQY1Jyx57SlJic5SwX18qs9rc7Jx8AkhSlk7KXr0oceTxb6MYXXd6Sf985O/g1/FA+jR3d3Fq1MTk7u7uHe1KUhTeb2YnOQjHYjR9yPhX5CQbPhELDNouaGDDM9i+BVa4dLtBw/oV06+qq154gKYYlZN9pm6QxQ76Xc72W12PzhhZ9BR+IlwuON8nGjtYxEZvr3vuHDvGMYiIZm6/kMGTsNvtIxG7jwnjGIlund65SkJdxZund3D5sXjHScPaeuuqc5CUuLx3d3DxjskseOXZLt57fQlJ37d47rWSliTjHdZbvi7Wc5S3Hy54U99TWUntczsJznOe9nM5SlKUsuc8mluc78pSeO7696tpFmWsK7M8YwjdjFmgrBOyWChQqqoUKqqoNVNYKUCGGiQQyIxtsNNjgWJE+uRiV2QJ2R8kkUwZDbnobVUYzIyMikm9EB7Nmtx16qq4bKhMbRAH1mBPdxkSCR36GjGZ2jNDO9rL044ks0T0yG8iyCrcCEHDiCAAssCbb5/jpqRQr0irfFGYut83+lu6lK5kDqOd1ceW5l2bFpjNpcq+3QpuY+i9qR5kut5c3h54IyMxfR0xBoE4tynxqngLUWqxjsdTnZx3OzsxJ5fO8xYCJsCX69vjB6AAsAKTogIKYPCD7kXyCRAx84AEK73TtLutTU5GRM6vhzolkd7mSJWMYN+QAgj7AK6g4M77HkCrVt1q1as1WrexFsdX6Zntkc4VCEImPiZ4EweiEEz4h/aF4xBh0O2n5bdWrVq1atXBz+nIfTB1Oxp9bs+D2fyJOrq2DlsWK9evif32K/ANCiRA7qEfcHUJp6Pyr43s0b2IPkL+eegz1pPB3/veLMUFlwHNYyvKWc0IJrGPrzAC9X1eZ70yRXaEeZYrWI+CXqep2PYvD199UKTtXuD+Cw9xZumgmp5UP6PNRpIfDVyUbHAysrKyu2ydlUaFHCd2N2aACFI4I9MyQyxno/yDSy9uhKKAD2/om5U6QuJBJ/6m4DzU0d5vuB1N+gAXFGBKmKVMBjKTnmxiAMkZHxbXlyPL4tEv5fIsUWvGsYznlu+TYx9mfXHiBT2sQACKGFhHxuB9ZzicGWLOoq3zqRHSOTzndOmzqY6FlvJ7XGPoKvA6+Hxu66o9iMOx6bB7x4TJ/r78e75Pl62Rh4Yx52Fq7bOHPBPtu6X1Z+8oJiXlrWcQAGCMSYYCJGABXj18R9TtuXoV9tXtKe8jMYDub/RtWhBC9bNNSEgSZCYpivFC8B+q17jOPyDP5fl8Ov9XmiF+JK1J5v5eBMl8ee+azWIwmJE6oeHNvOd9OpN2NqW4p2/NqfHez5te7NfXDpswGI1mKtvLQcxzMC8ZWKuBIR0GvFqdPRUTY7Cs1eMroT6cDG3CQ0kkxAGIwsygEiGt1v5d7ue7JabhnjvPpOvXjrx8Q+xM8CrIM10NB95qDSGdUYgkktBnucHKjkT8jBs8jk5tjLrIr5LkPjzEsKBQ0eszWavmLz54VIxej6OXJbhiMpoDsVACPP5noyXaai9jn822KWAcIyOB32Bi84eTXlQ6lZehd9XOyLrnMn+4habGawYsNY2n8U0XudlYlVfNBfmioMVESL0/Xlb1xz2SmWGa4Tz0l883wRGGcf8OTk5T6PL0fK8rw6ug+ixb9+j413XlaOjo6LeMABypLXJvw+p56QvRK/15Ge7q0867mern+hUz4dbv3scQORC7iHbOEQTwPRJjRc7sneRykY6TmShP5/QPQbb24AAHgKvozFWimzOxcWV6dB/1eczECMNvIyo4OjIe4fHZXqsnEGIOUqEBAIkA7goQHFhSSQWAs+nM7y558P6zGUTTWtAarsrccRgYqI8Lr7JEyeD7NDr6+zXq1avp1av5npVP3O4syV+FW26bjSA082dBZeGHRgD4A1fHuqe56KS6um73Bb3cC56k1XZe6f5MlSLjs1MS7Vr9TD5zR6T7Nvodja117jY9OiWiO/y++mhpJBAKIBQggAiFEeMvCAUFrvqJRIlEmpQQ4lDdMpTaJ1BwKSGDm5BMISp9TzG35nIybzlOUms+Xe+49v0m4v8/rcO2zG919pl6HQ0PqUZVF33UHqxb8WR7o02bNm/VwfOnupRcTuOOYhCEAkgXETEOBsZIKrybCwud2supl5dORk/o2v78/hNUkyj5zkyCRChjIi54c5eixIEQQzEUBwCOqBSCKZEpBUVAbGzBSQE0pziKJSoU0IJSlEUKbEpDQKcnKQ0KTVFChCBBWRAaGDRDNSTzmCdiqQIJAjJkiaqYVUmF46pUKjciiTSmiSIhlQiGMS4UkppoEuLlIQgCgAqN4abJiQCquGqGpiCKRgFKcpgTQ6TTTU6oBYsWbPN/U2I5ej7lttttttudu9r9rvYVuS3/s+4/GnwtvJyeJc28rI9vZdeJnYYG/BhpssssoTJnMZa8G5W0SwS3AcyJaxZJeTXMYh15zJ807A4Y3JqTiDqznTrzh7d7pvpzdHLGvMg2BqjmTlzmDozJ9iHeHszpzYHyTqjeHvzwDVGSZJknGGuOJOKPnGxOoN2cSOtHuB7geYOvCva3bilsjLmpx6rHrUAA0abSc1T+7OEavP3lraWj96+f/g/kEV29u7tbd26H6WgViCXQyCjRVqwwta6SJ/73Hsyivv+qAS7a7IUNmyJbX6njs1vAnJWc48K2RaL9+umXvrNRArlSFbVgmSuIiXVusaQ7CGbm2yP7pbrJ+mc4+btxAqi0JtCMG0Xxcv15ybhboqFhfOZhS7kuYPJHqVgoXUlG+ncxbmVuZRTaB0iFMMzZgSWF7bMB6BMVBIFvUyIsr75epkXLDBryGLXH1WpbRo0tlNjHiDeThuN0Wde5ljqZDK8qrsnAt0KNGjqY2T6xuZs4iVVpqHNo/DfwyeECgu+bILZKF2obZUYQ52qrbk9ZiXBaBZOPTYWr8Lq3Nz2upielXvMSm0gg5t23iKXVkHkybCFSBYU0O9XFroaUpAB+4kLSNH7/4avrAOJWVCY5DWvLLX9Lucrp8naUz2sE4pidpplqfevt1DhY2wwrDb9HhIO82pXhuu4csXmn2/uOhFttOGekS5yopK7OfuSlKulmsKPBotaLoS1NEk/2k9IQmjTnNWscjTtami/3IEVDGgsW3OPRxjyXko0X0hGJ6BKQCH435fi/L+XlQ/CaGzlvyUJzEx4TWjm7lYsKepi4rldyUWdelAd+EUo4hCk2KWa0c8DZqU+BUkIVUX7w16FX16vaKFa70zOt7rrIBrY3rqRPsdFMJGrVc4005+1PkfOf1DyBU0JlLx58P6WknTYsOjvz/GRc0qKunpvqenpxsQ+CBaBB4+hvGJRo997ahoaDsj5srfe/5U918klRUOc+IdGjVQzZr0s2bHxWZznMezX0B/mS7OVNJkzZvG7fe3lHr0PrXtP6j+juexi/Jzf9Pl/ILqgcb4Twev/K7E0TCIno7U/FGNjXbuZmrUs2F6IHIHIHAGBgPrwbU4ik7z1L6+ThxTqriBk1JDvJvs/ZW6K686PSWhwEVNtiwwx6A2+X7JcLigSBBBBA99vd3xy0dwUw9AegO0DYuZ72fWphfmnnknGoKiqqU9QUUT0FPQS4qYWFhYXaBxR1y9kwo8KA+BomXgHbyRqyHkTKf0BfZFjs7LckkknqRbbI/nQkvMqjd9LpT1KlRCmoUY9LC8qxtx5adM9PtO2sTyRyOSXn5qtq067wnk0A1YXxa1iKk8KsEMGklU1dXl+J3Xt/a4d7RWtM9vZs4Hid862cw8Ha5Xi0mzO3+vgUC4XTSVc7VVTKkmKntqIiFhYWFQTBlZeVlZOVlZdVC/uhWcJQk0XHJ3jUzEGY4aTYm0IbFMtwEHkNIAkNMYHjam+qRkZLw8jJLNUAOj8l79q/xvdEIQTZaLlcy6lkeQMhGFGaumGSdkyZMt3wpY9eHV9gQHaAAIdGgGMk9xLaFuucdSc/k8afyFH2jAziaep8vwrtrakfS3Ox1ddoEitGetNNMssstKe6krY9O78wACUQhN9Rm3bWhR54nzopfi4m9aVvZ2habVbbV81r6Rb/DoqU1HnnnqTAMT+HO9DAmE+seoAABxPk9DwV7ly5eUriW8S5++lb/xM41VAAGlpaMgAACfA3eDxLVoqVMouQEAGu5FE09FCUtFFCTzz07w+QU000M00zGf3V/9t3Sb+sB/2B+k/7DSCP9r4UpZORkZNFFRNLosEVXIY2lJgTNDkSY5LGaPz0ATzk8yhwwUDhpSlJtjkBEQkOIQREATNpIGiUoQRECSiIQREJQ4Y4ghgENKGkpAgGSYpNA2Q5AhpQ1JgmxQxIbUNBDFDShw4aYlDGRDIYmQyIYyEmKGQkmQyEyGNg2QxJsABpiYmJsaTbUMTEobaYmwABwkxMUMTITY4ZCTY22223ChoQpIQMBCTEAwEmAmCQjBWIxpi/s92GDkYWFQT5HUqzTDGMtygZESMcHOc5FkoS+SYxjAV/J9389C1a2cD/7KrYZrahV69eEzLMnVb2jL99cvp/ZU9/f2rtu378j3QBsBcX0IArsARcsWrlyycC/yOt0esnBBBtdF11xx1httsgPkKyyoh555QPUeCZAjKAjHMCIgRgRiMCIwNrck5jGNA1BBBTYlsZ0EEB4INVy/2bTDTUf0DGJsaEG7ZAMYmm22wYNDYxjYNMAFCEIAQIgEiAEiFAQkgCIAIAIAIRGYEmiIQBf37UkRCuVatY1xbld1lFxtxikgyyyv4/lY37u+cx2Auww98MsJuxC/BCz33WO1Ayyz2nA1tdKIeZWZYZSMREyzkotNNNLmXxVMVfVXVp4vBaaXcecDmLwHGW23HHLduvTLhs3kCvBsqjVg6/BrE8I4H049dFoiJwaaLfWbvqi62gBADbXq0EBCoZ6ZFpQIChSlF7LLPxbVGKq92zfM9tXtrdwyhXviCH/36CM5gr8Jmu+aSgYJtANp3kjAvidvhF8qQ5Xj/ERn2NXyUGKm423h4Xx6atrssODFgkIV/A7vAYhR4CEEsBMQoIQ5HlC57/4u5IpwoSFd4TU+A=", + "comp_options": " -DCK_PARAM_PROBLEM_N=32 -DCK_PARAM_PROBLEM_K=128 -DCK_PARAM_PROBLEM_C=128 -DCK_PARAM_PROBLEM_HI=28 -DCK_PARAM_PROBLEM_WI=28 -DCK_PARAM_PROBLEM_HO=28 -DCK_PARAM_PROBLEM_WO=28 -DCK_PARAM_PROBLEM_Y=3 -DCK_PARAM_PROBLEM_X=3 -DCK_PARAM_PROBLEM_CONV_STRIDE_H=1 -DCK_PARAM_PROBLEM_CONV_STRIDE_W=1 -DCK_PARAM_PROBLEM_CONV_DILATION_H=1 -DCK_PARAM_PROBLEM_CONV_DILATION_W=1 -DCK_PARAM_PROBLEM_LEFT_PAD_H=1 -DCK_PARAM_PROBLEM_LEFT_PAD_W=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_H=1 -DCK_PARAM_PROBLEM_RIGHT_PAD_W=1 -DCK_PARAM_PROBLEM_CONV_GROUP_COUNTS=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_FORWARD=1 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_DATA=0 -DCK_PARAM_PROBLEM_CONV_DIRECTION_BACKWARD_WEIGHT=0 -DCK_PARAM_TUNABLE_BLOCK_SIZE=256 -DCK_PARAM_TUNABLE_B_PER_BLOCK=16 -DCK_PARAM_TUNABLE_K_PER_BLOCK=128 -DCK_PARAM_TUNABLE_E_PER_BLOCK=4 -DCK_PARAM_DEPENDENT_GRID_SIZE=196 -DCK_PARAM_GEMM_N_REPEAT=2 -DCK_PARAM_GEMM_M_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_N_PER_THREAD_SUB_C=4 -DCK_PARAM_GEMM_M_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL0_CLUSTER=4 -DCK_PARAM_GEMM_M_LEVEL1_CLUSTER=4 -DCK_PARAM_GEMM_N_LEVEL1_CLUSTER=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_E=4 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N1=2 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_B=16 -DCK_PARAM_IN_BLOCK_COPY_CLUSTER_LENGTHS_N2=2 -DCK_PARAM_IN_BLOCK_COPY_SRC_DATA_PER_READ_B=1 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_E=2 -DCK_PARAM_WEI_BLOCK_COPY_CLUSTER_LENGTHS_K=128 -DCK_PARAM_WEI_BLOCK_COPY_SRC_DATA_PER_READ_E=2 -DCK_PARAM_EPACK_LENGTH=2 -DCK_THREADWISE_GEMM_USE_AMD_INLINE_ASM=1 -DCK_USE_AMD_INLINE_ASM=1 --std=c++14 -DCK_USE_AMD_BUFFER_ATOMIC_FADD=0 -DCK_BLOCK_SYNC_LDS_WITHOUT_SYNC_VMEM=1 -DCK_WORKAROUND_SWDEV_229564=1 -DCK_WORKAROUND_SWDEV_231101=1 -DCK_USE_AMD_BUFFER_ADDRESSING=1 -DCK_USE_AMD_V_FMAC_F32=0 -DMIOPEN_USE_FP16=0 -DMIOPEN_USE_FP32=0 -DMIOPEN_USE_INT8=0 -DMIOPEN_USE_INT8x4=0 -DMIOPEN_USE_BFP16=1 -DMIOPEN_USE_INT32=0 -DMIOPEN_USE_RNE_BFLOAT16=1 -DCK_PARAM_IN_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2 -DCK_PARAM_WEI_BLOCK_COPY_DST_DATA_PER_WRITE_EPACK=2", + "kernel_file": "static_kernel_gridwise_convolution_implicit_gemm_v4r1_nchw_kcyx_nkhw_lds_double_buffer.cpp", + "md5_sum": "168b32be3ffcd94e9455a5f0666bde89", + "uncompressed_size": 44520 + } + ], + "perf_compiled": true, + "solver_id": "ConvHipImplicitGemmV4R1Fwd" + } + ], + "network_config": "128x28x28x3x3x128x28x28x32xNCHWxBF16x1x1x1x1x1x1x1xF", + "num_cu": 60, + "steps": [ + "alloc_buf", + "miopen_perf_eval" + ], + "tag": "resnet50" + }, + "is_winograd_only": false, + "miopen_perf_eval_result": [ + { + "algorithm": "miopenConvolutionFwdAlgoImplicitGEMM", + "bias": 0, + "data_type": 5, + "direction": 0, + "evaluated": true, + "layout": "NCHW", + "params": "16,64,8,2,2,2,4,4,4,4,8,2,16,1,4,64", + "reason": "Success", + "solver_name": "ConvHipImplicitGemmV4R1Fwd", + "time": 1.862347960472107, + "workspace": 0 + } + ], + "network_config": "128x28x28x3x3x128x28x28x32xNCHWxBF16x1x1x1x1x1x1x1xF" + } +] diff --git a/tests/pdb_check_all.json b/tests/pdb_check_all.json new file mode 100644 index 0000000000..629dac2ac8 --- /dev/null +++ b/tests/pdb_check_all.json @@ -0,0 +1,6 @@ +[ +{ +"pdb_verif": true, +"steps": ["perf_db_test"] +} +] diff --git a/tests/pdb_check_gfx906.json b/tests/pdb_check_gfx906.json new file mode 100644 index 0000000000..8e4c34fa9d --- /dev/null +++ b/tests/pdb_check_gfx906.json @@ -0,0 +1,8 @@ +[ +{ +"pdb_verif": true, +"arch": "gfx906", +"num_cu": 60, +"steps": ["perf_db_test"] +} +] diff --git a/tests/pdb_check_gfx908.json b/tests/pdb_check_gfx908.json new file mode 100644 index 0000000000..7693f1c113 --- /dev/null +++ b/tests/pdb_check_gfx908.json @@ -0,0 +1,8 @@ +[ +{ +"pdb_verif": true, +"arch": "gfx908", +"num_cu": 120, +"steps": ["perf_db_test"] +} +] diff --git a/tests/pdb_check_gfx90a.json b/tests/pdb_check_gfx90a.json new file mode 100644 index 0000000000..d7470ac50d --- /dev/null +++ b/tests/pdb_check_gfx90a.json @@ -0,0 +1,8 @@ +[ +{ +"pdb_verif": true, +"arch": "gfx90a", +"num_cu": 110, +"steps": ["perf_db_test"] +} +]